@temporal-cortex/cortex-mcp 0.1.1

package/README.md

@@ -0,0 +1,5 @@
+# @temporal-cortex/cortex-mcp
+
+MCP server for AI-native calendar operations.
+
+**Full documentation, examples, and guides: [github.com/billylui/temporal-cortex-mcp](https://github.com/billylui/temporal-cortex-mcp)**

package/bin/run.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+// Platform-specific binary launcher for @temporal-cortex/cortex-mcp.
+//
+// Resolution strategy:
+// 1. Try the platform-specific optional dependency (installed by npm automatically)
+// 2. Fall back to a binary downloaded by the postinstall script
+// 3. Provide a clear error message if neither is available
+
+"use strict";
+
+const { execFileSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+
+const PLATFORM_MAP = {
+  "darwin-arm64": "@temporal-cortex/cortex-mcp-darwin-arm64",
+  "darwin-x64": "@temporal-cortex/cortex-mcp-darwin-x64",
+  "linux-x64": "@temporal-cortex/cortex-mcp-linux-x64",
+  "linux-arm64": "@temporal-cortex/cortex-mcp-linux-arm64",
+  "win32-x64": "@temporal-cortex/cortex-mcp-win32-x64",
+};
+
+const BINARY_NAME = os.platform() === "win32" ? "cortex-mcp.exe" : "cortex-mcp";
+
+function getBinaryPath() {
+  const platformKey = `${os.platform()}-${os.arch()}`;
+  const packageName = PLATFORM_MAP[platformKey];
+
+  if (!packageName) {
+    throw new Error(
+      `Unsupported platform: ${platformKey}. ` +
+        `Supported: ${Object.keys(PLATFORM_MAP).join(", ")}`
+    );
+  }
+
+  // Strategy 1: Try the platform-specific npm package.
+  try {
+    const packageDir = path.dirname(require.resolve(`${packageName}/package.json`));
+    const binPath = path.join(packageDir, "bin", BINARY_NAME);
+    if (fs.existsSync(binPath)) {
+      return binPath;
+    }
+  } catch {
+    // Package not installed — try fallback.
+  }
+
+  // Strategy 2: Try the postinstall fallback binary.
+  const fallbackPath = path.join(__dirname, "..", "bin", BINARY_NAME);
+  if (fs.existsSync(fallbackPath) && fallbackPath !== __filename) {
+    return fallbackPath;
+  }
+
+  throw new Error(
+    `Could not find the cortex-mcp binary for ${platformKey}.\n` +
+      `Try reinstalling: npm install @temporal-cortex/cortex-mcp\n` +
+      `If the problem persists, please file an issue at:\n` +
+      `https://github.com/billylui/temporal-cortex-mcp/issues`
+  );
+}
+
+try {
+  const binPath = getBinaryPath();
+
+  // Pass through all arguments and stdio.
+  execFileSync(binPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+  });
+} catch (err) {
+  if (err.status !== undefined) {
+    // Binary exited with a non-zero code — propagate it.
+    process.exit(err.status);
+  }
+  console.error(err.message);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@temporal-cortex/cortex-mcp",
+  "version": "0.1.1",
+  "description": "MCP server for AI-native calendar operations — atomic booking, RRULE expansion, and availability merging",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/billylui/temporal-cortex-mcp.git"
+  },
+  "homepage": "https://github.com/billylui/temporal-cortex-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/billylui/temporal-cortex-mcp/issues"
+  },
+  "mcpName": "io.github.billylui/temporal-cortex-mcp",
+  "keywords": [
+    "mcp",
+    "calendar",
+    "google-calendar",
+    "ai",
+    "scheduling",
+    "booking",
+    "rrule",
+    "availability"
+  ],
+  "bin": {
+    "cortex-mcp": "bin/run.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "optionalDependencies": {
+    "@temporal-cortex/cortex-mcp-darwin-arm64": "0.1.1",
+    "@temporal-cortex/cortex-mcp-darwin-x64": "0.1.1",
+    "@temporal-cortex/cortex-mcp-linux-x64": "0.1.1",
+    "@temporal-cortex/cortex-mcp-linux-arm64": "0.1.1",
+    "@temporal-cortex/cortex-mcp-win32-x64": "0.1.1"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+// Postinstall fallback for @temporal-cortex/cortex-mcp.
+//
+// If the platform-specific optional dependency wasn't installed (e.g., because
+// `--no-optional` was used or the platform isn't in optionalDependencies),
+// this script downloads the correct binary from GitHub Releases.
+//
+// This is a best-effort fallback — the primary distribution mechanism is the
+// platform-specific npm packages via optionalDependencies.
+
+"use strict";
+
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execSync } = require("child_process");
+
+const VERSION = require("../package.json").version;
+const BINARY_NAME = os.platform() === "win32" ? "cortex-mcp.exe" : "cortex-mcp";
+
+const PLATFORM_MAP = {
+  "darwin-arm64": "cortex-mcp-darwin-arm64",
+  "darwin-x64": "cortex-mcp-darwin-x64",
+  "linux-x64": "cortex-mcp-linux-x64",
+  "linux-arm64": "cortex-mcp-linux-arm64",
+  "win32-x64": "cortex-mcp-win32-x64",
+};
+
+function getPlatformKey() {
+  return `${os.platform()}-${os.arch()}`;
+}
+
+function alreadyInstalled() {
+  const platformKey = getPlatformKey();
+  const packageNames = {
+    "darwin-arm64": "@temporal-cortex/cortex-mcp-darwin-arm64",
+    "darwin-x64": "@temporal-cortex/cortex-mcp-darwin-x64",
+    "linux-x64": "@temporal-cortex/cortex-mcp-linux-x64",
+    "linux-arm64": "@temporal-cortex/cortex-mcp-linux-arm64",
+    "win32-x64": "@temporal-cortex/cortex-mcp-win32-x64",
+  };
+
+  const packageName = packageNames[platformKey];
+  if (!packageName) return false;
+
+  try {
+    require.resolve(`${packageName}/package.json`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function downloadBinary() {
+  const platformKey = getPlatformKey();
+  const artifact = PLATFORM_MAP[platformKey];
+
+  if (!artifact) {
+    console.warn(
+      `[cortex-mcp] No prebuilt binary for ${platformKey}. ` +
+        `You may need to build from source.`
+    );
+    return;
+  }
+
+  // Skip if the platform package is already installed.
+  if (alreadyInstalled()) {
+    return;
+  }
+
+  const tarball = `${artifact}.tar.gz`;
+  const url = `https://github.com/billylui/temporal-cortex-mcp/releases/download/mcp-v${VERSION}/${tarball}`;
+  const binDir = path.join(__dirname, "..", "bin");
+  const tmpFile = path.join(os.tmpdir(), tarball);
+
+  console.log(`[cortex-mcp] Downloading binary for ${platformKey}...`);
+
+  try {
+    await download(url, tmpFile);
+
+    // Extract the binary from the tarball.
+    fs.mkdirSync(binDir, { recursive: true });
+    execSync(`tar -xzf "${tmpFile}" -C "${binDir}"`, { stdio: "pipe" });
+
+    // Make executable on Unix.
+    if (os.platform() !== "win32") {
+      fs.chmodSync(path.join(binDir, BINARY_NAME), 0o755);
+    }
+
+    console.log(`[cortex-mcp] Binary installed successfully.`);
+  } catch (err) {
+    console.warn(
+      `[cortex-mcp] Failed to download binary: ${err.message}\n` +
+        `You can manually download from: ${url}`
+    );
+  } finally {
+    // Clean up temp file.
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {
+      // Ignore cleanup errors.
+    }
+  }
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https
+      .get(url, (response) => {
+        // Follow redirects (GitHub releases redirect to S3).
+        if (response.statusCode === 302 || response.statusCode === 301) {
+          file.close();
+          fs.unlinkSync(dest);
+          return download(response.headers.location, dest).then(resolve, reject);
+        }
+
+        if (response.statusCode !== 200) {
+          file.close();
+          fs.unlinkSync(dest);
+          return reject(new Error(`HTTP ${response.statusCode}`));
+        }
+
+        response.pipe(file);
+        file.on("finish", () => {
+          file.close(resolve);
+        });
+      })
+      .on("error", (err) => {
+        file.close();
+        try {
+          fs.unlinkSync(dest);
+        } catch {
+          // Ignore.
+        }
+        reject(err);
+      });
+  });
+}
+
+downloadBinary().catch(() => {
+  // Non-fatal — the binary just won't be available.
+});