@apono-io/apono-mcp 0.1.0

package/bin/run.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execFileSync } = require("child_process");
+const { ensureBinary } = require("../lib/download");
+
+// Commands that should be passed directly to the CLI (not prefixed with "mcp")
+const DIRECT_COMMANDS = ["login", "logout", "version"];
+
+async function main() {
+  try {
+    const binaryPath = await ensureBinary();
+    const userArgs = process.argv.slice(2);
+
+    let args;
+    if (userArgs.length > 0 && DIRECT_COMMANDS.includes(userArgs[0])) {
+      // Pass directly: apono login, apono logout, etc.
+      args = userArgs;
+    } else {
+      // Default: apono mcp <args>
+      args = ["mcp", ...userArgs];
+    }
+
+    execFileSync(binaryPath, args, {
+      stdio: "inherit",
+      env: process.env,
+    });
+  } catch (err) {
+    if (err.status != null) {
+      process.exit(err.status);
+    }
+    process.stderr.write(`Error: ${err.message}\n`);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/download.js

@@ -0,0 +1,203 @@
+"use strict";
+
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execFileSync } = require("child_process");
+const { BINARY_DIR, BINARY_NAME, BINARY_PATH, RELEASES_BASE_URL } = require("./paths");
+
+function getPlatform() {
+  const platform = process.platform;
+  switch (platform) {
+    case "darwin":
+      return "darwin";
+    case "linux":
+      return "linux";
+    case "win32":
+      return "windows";
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+function getArch() {
+  const arch = process.arch;
+  switch (arch) {
+    case "x64":
+      return "amd64";
+    case "arm64":
+      return "arm64";
+    case "arm":
+      return "armv7";
+    default:
+      throw new Error(`Unsupported architecture: ${arch}`);
+  }
+}
+
+function getArchiveExtension() {
+  return process.platform === "win32" ? "zip" : "tar.gz";
+}
+
+function httpsGet(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, { headers: { "User-Agent": "apono-mcp-npm" } }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return httpsGet(res.headers.location).then(resolve, reject);
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      })
+      .on("error", reject);
+  });
+}
+
+function getInstalledVersion() {
+  try {
+    if (!fs.existsSync(BINARY_PATH)) {
+      return null;
+    }
+    const output = execFileSync(BINARY_PATH, ["--version"], {
+      encoding: "utf8",
+      timeout: 10000,
+    }).trim();
+    const match = output.match(/v?(\d+\.\d+\.\d+\S*)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+async function getLatestVersion() {
+  const url = `${RELEASES_BASE_URL}/cli/latest.txt`;
+  const data = await httpsGet(url);
+  return data.toString("utf8").trim();
+}
+
+function downloadToFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, { headers: { "User-Agent": "apono-mcp-npm" } }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return downloadToFile(res.headers.location, dest).then(resolve, reject);
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
+        }
+        const file = fs.createWriteStream(dest);
+        res.pipe(file);
+        file.on("finish", () => file.close(resolve));
+        file.on("error", reject);
+      })
+      .on("error", reject);
+  });
+}
+
+function extractTarGz(archivePath, destDir) {
+  execFileSync("tar", ["xzf", archivePath, "-C", destDir], { timeout: 60000 });
+}
+
+function extractZip(archivePath, destDir) {
+  if (process.platform === "win32") {
+    execFileSync("powershell", [
+      "-Command",
+      `Expand-Archive -Force -Path '${archivePath}' -DestinationPath '${destDir}'`,
+    ], { timeout: 60000 });
+  } else {
+    execFileSync("unzip", ["-o", archivePath, "-d", destDir], { timeout: 60000 });
+  }
+}
+
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const LAST_CHECK_FILE = path.join(BINARY_DIR, ".last-update-check");
+
+function shouldCheckForUpdate() {
+  try {
+    if (!fs.existsSync(LAST_CHECK_FILE)) return true;
+    const lastCheck = parseInt(fs.readFileSync(LAST_CHECK_FILE, "utf8"), 10);
+    return Date.now() - lastCheck > UPDATE_CHECK_INTERVAL_MS;
+  } catch {
+    return true;
+  }
+}
+
+function recordUpdateCheck() {
+  try {
+    fs.mkdirSync(BINARY_DIR, { recursive: true });
+    fs.writeFileSync(LAST_CHECK_FILE, String(Date.now()));
+  } catch {
+    // ignore
+  }
+}
+
+async function ensureBinary() {
+  const installedVersion = getInstalledVersion();
+
+  // If binary exists and we checked recently, skip the network call
+  if (installedVersion && !shouldCheckForUpdate()) {
+    return BINARY_PATH;
+  }
+
+  let latestVersion;
+  try {
+    latestVersion = await getLatestVersion();
+    recordUpdateCheck();
+  } catch (err) {
+    if (installedVersion) {
+      process.stderr.write(`Warning: Could not check for updates: ${err.message}\n`);
+      return BINARY_PATH;
+    }
+    throw new Error(`Failed to fetch latest version: ${err.message}`);
+  }
+
+  if (installedVersion === latestVersion) {
+    return BINARY_PATH;
+  }
+
+  const platformStr = getPlatform();
+  const archStr = getArch();
+  const ext = getArchiveExtension();
+  const archiveName = `apono-agentic-cli_${latestVersion}_${platformStr}_${archStr}.${ext}`;
+  const downloadUrl = `${RELEASES_BASE_URL}/cli/v${latestVersion}/${archiveName}`;
+
+  process.stderr.write(`Downloading Apono CLI v${latestVersion}...\n`);
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "apono-"));
+  const archivePath = path.join(tmpDir, archiveName);
+
+  try {
+    await downloadToFile(downloadUrl, archivePath);
+
+    fs.mkdirSync(BINARY_DIR, { recursive: true });
+
+    if (ext === "zip") {
+      extractZip(archivePath, tmpDir);
+    } else {
+      extractTarGz(archivePath, tmpDir);
+    }
+
+    const extractedBinary = path.join(tmpDir, BINARY_NAME);
+    if (!fs.existsSync(extractedBinary)) {
+      throw new Error(`Binary not found in archive at ${extractedBinary}`);
+    }
+
+    fs.copyFileSync(extractedBinary, BINARY_PATH);
+    fs.chmodSync(BINARY_PATH, 0o755);
+
+    process.stderr.write(`Apono CLI v${latestVersion} installed to ${BINARY_PATH}\n`);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+
+  return BINARY_PATH;
+}
+
+module.exports = { ensureBinary };

package/lib/paths.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const path = require("path");
+const os = require("os");
+
+const RELEASES_BASE_URL = "https://apono-agentic-releases.s3.amazonaws.com";
+
+const BINARY_DIR = path.join(os.homedir(), ".apono", "bin");
+const BINARY_NAME = process.platform === "win32" ? "apono.exe" : "apono";
+const BINARY_PATH = path.join(BINARY_DIR, BINARY_NAME);
+
+module.exports = {
+  BINARY_DIR,
+  BINARY_NAME,
+  BINARY_PATH,
+  RELEASES_BASE_URL,
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@apono-io/apono-mcp",
+  "version": "0.1.0",
+  "description": "Apono MCP server for Claude Code, Claude Desktop, and Cursor",
+  "bin": {
+    "apono-mcp": "./bin/run.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "apono",
+    "mcp",
+    "claude",
+    "cursor",
+    "access-management"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apono-io/apono-cli-agentic.git"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}