@atlassian/mcp-compressor 0.35.0 → 0.36.0

package/dist/cli.js

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
 import { Command, Option } from "commander";
 import { spawn } from "node:child_process";
-import { accessSync, closeSync, constants, existsSync, openSync, readSync } from "node:fs";
-import { delimiter, dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { loadNativeCore } from "./native.js";
 import { VERSION } from "./version.js";
 function parseBackendArg(backendArgs) {
     if (backendArgs.length === 0) {
@@ -120,90 +118,6 @@ function parseClearOAuthArgs(args) {
     const options = clearProgram.opts();
     return { ...(target ? { target } : {}), all: options.all ?? false };
 }
-/**
- * Resolve a bare binary name to an absolute path using the PATH environment
- * variable.  Returns null when the name cannot be found in any PATH directory.
- */
-function resolveFromPath(name) {
-    const pathEnv = process.env.PATH ?? "";
-    const dirs = pathEnv.split(delimiter);
-    const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";") : [""];
-    for (const dir of dirs) {
-        for (const ext of exts) {
-            const candidate = join(dir, name + ext);
-            try {
-                accessSync(candidate, constants.X_OK);
-                return candidate;
-            }
-            catch {
-                // not executable or not found — try next
-            }
-        }
-    }
-    return null;
-}
-/**
- * Return true when the file at `filePath` begins with a native-executable
- * magic number (ELF, Mach-O, or PE).  A JS shim that starts with a `#!`
- * shebang (or any other non-native header) returns false.
- *
- * This guards against the fork-bomb that occurs when the npm-installed
- * `mcp-compressor` bin shim is the only entry on PATH: spawning it would
- * re-invoke this very script rather than the Rust binary.
- */
-function isNativeExecutable(filePath) {
-    let fd;
-    try {
-        fd = openSync(filePath, "r");
-    }
-    catch {
-        return false;
-    }
-    try {
-        const buf = Buffer.alloc(4);
-        const n = readSync(fd, buf, 0, 4, 0);
-        if (n < 4)
-            return false;
-        // ELF (Linux/BSD): \x7fELF
-        if (buf[0] === 0x7f && buf[1] === 0x45 && buf[2] === 0x4c && buf[3] === 0x46)
-            return true;
-        // PE (Windows): MZ
-        if (buf[0] === 0x4d && buf[1] === 0x5a)
-            return true;
-        // Mach-O (macOS) — big-endian and little-endian variants, including fat/universal
-        const be = buf.readUInt32BE(0);
-        if (be === 0xfeedface || // Mach-O 32-bit BE
-            be === 0xfeedfacf || // Mach-O 64-bit BE
-            be === 0xcefaedfe || // Mach-O 32-bit LE
-            be === 0xcffaedfe || // Mach-O 64-bit LE
-            be === 0xcafebabe || // Mach-O fat binary
-            be === 0xbebafeca // Mach-O fat binary LE
-        )
-            return true;
-        return false;
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function candidateCoreBinaries() {
-    const candidates = [];
-    if (process.env.MCP_COMPRESSOR_BINARY) {
-        candidates.push(process.env.MCP_COMPRESSOR_BINARY);
-    }
-    // Resolve the bare name from PATH and only include it when the resolved
-    // file is a native binary, not a JS shim.  Without this check the npm bin
-    // shim (which maps `mcp-compressor` back to this very script) would be
-    // spawned indefinitely, creating a fork bomb.
-    const resolved = resolveFromPath("mcp-compressor");
-    if (resolved !== null && isNativeExecutable(resolved)) {
-        candidates.push(resolved);
-    }
-    const here = dirname(fileURLToPath(import.meta.url));
-    candidates.push(join(here, "..", "..", "target", "debug", process.platform === "win32" ? "mcp-compressor.exe" : "mcp-compressor"));
-    candidates.push(join(process.cwd(), "..", "target", "debug", process.platform === "win32" ? "mcp-compressor.exe" : "mcp-compressor"));
-    return candidates;
-}
 function translateArgsForRust(args) {
     const clearOAuth = parseClearOAuthArgs(args);
     if (clearOAuth) {
@@ -211,34 +125,44 @@ function translateArgsForRust(args) {
     }
     return args;
 }
+/**
+ * Run the Rust CLI. The npm package ships the native addon, so by default the
+ * CLI runs in-process and needs no separately installed binary (like the
+ * Python package). `MCP_COMPRESSOR_BINARY` runs a specific binary instead.
+ */
 async function runRustCoreCli(args) {
-    for (const binary of candidateCoreBinaries()) {
-        if (!existsSync(binary)) {
-            continue;
-        }
-        const child = spawn(binary, translateArgsForRust(args), { stdio: "inherit" });
-        return await new Promise((resolve, reject) => {
-            child.on("error", (error) => {
-                if (error.code === "ENOENT") {
-                    resolve(127);
-                    return;
-                }
-                reject(error);
-            });
-            child.on("exit", (code, signal) => {
-                if (signal) {
-                    resolve(1);
-                    return;
-                }
-                resolve(code ?? 0);
-            });
-        });
+    const rustArgs = translateArgsForRust(args);
+    const binary = process.env.MCP_COMPRESSOR_BINARY;
+    if (!binary) {
+        return loadNativeCore().runCliJson(JSON.stringify(["mcp-compressor", ...rustArgs]), VERSION);
     }
-    console.error("mcp-compressor binary was not found. Build it with `cargo build -p mcp-compressor-core` or set MCP_COMPRESSOR_BINARY.");
-    return 127;
+    return await new Promise((resolve, reject) => {
+        const child = spawn(binary, rustArgs, { stdio: "inherit" });
+        child.on("error", (error) => {
+            if (error.code === "ENOENT") {
+                console.error(`MCP_COMPRESSOR_BINARY not found: ${binary}`);
+                resolve(127);
+                return;
+            }
+            reject(error);
+        });
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                resolve(1);
+                return;
+            }
+            resolve(code ?? 0);
+        });
+    });
 }
 async function main() {
-    const exitCode = await runRustCoreCli(process.argv.slice(2));
+    const args = process.argv.slice(2);
+    if (args.length === 1 && (args[0] === "--version" || args[0] === "-V")) {
+        // The Rust core is versioned by the npm release, not its Cargo manifest.
+        console.log(`mcp-compressor ${VERSION}`);
+        return;
+    }
+    const exitCode = await runRustCoreCli(args);
     process.exitCode = exitCode;
 }
 main().catch((error) => {

package/dist/native.d.ts

@@ -19,13 +19,15 @@ export interface NativeCore {
     rememberOauthBackendJson(backendUri: string, backendName: string, storeDir: string): void;
     listOauthCredentialsJson(): string;
     clearOauthCredentialsJson(target?: string | null): string;
+    /** Run the whole CLI in-process; blocks until it exits. */
+    runCliJson(argvJson: string, version?: string | null): number;
     startCompressedSessionJson(configJson: string, backendsJson: string): Promise<NativeCompressedSession>;
     startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: string, refreshProviders: () => Promise<string>): Promise<NativeCompressedSession>;
     startCompressedSessionFromMcpConfigJson(configJson: string, mcpConfigJson: string): Promise<NativeCompressedSession>;
 }
 export interface NativeCompressedSession {
     infoJson(): string;
-    close(): void;
+    close(): Promise<void>;
     updateAuthProviderHeadersJson(providerIndex: number, headersJson: string): void;
 }
 export declare function loadNativeCore(): NativeCore;

package/dist/native_client.d.ts

@@ -65,12 +65,13 @@ export declare function normalizeServers(servers: NativeServersInput): Promise<N
  * Internal; not part of the public package surface.
  */
 export declare function adoptNativeSession<T>(session: {
-    close(): void;
+    close(): void | Promise<void>;
 }, build: () => T): T;
 export declare class CompressorProxy {
     private readonly session;
     private readonly defaultServer;
     private closed;
+    private closing;
     constructor(session: CompressedSession, defaultServer: string | null);
     info(): CompressedSessionInfo;
     get bridgeUrl(): string;
@@ -84,7 +85,7 @@ export declare class CompressorProxy {
     invoke(tool: string, toolInput?: Record<string, unknown>, options?: {
         server?: string;
     }): Promise<string>;
-    close(): void;
+    close(): Promise<void>;
     toExecutableTools(): Record<string, ExecutableTool>;
     writeClient(kind: GeneratedClientKind, outputDir: string, options?: {
         name?: string;

package/dist/native_client.js

@@ -169,7 +169,7 @@ export function adoptNativeSession(session, build) {
     }
     catch (error) {
         try {
-            session.close();
+            void Promise.resolve(session.close()).catch(() => { });
         }
         catch {
             // Closing a session that never became reachable is best effort.
@@ -181,6 +181,7 @@ export class CompressorProxy {
     session;
     defaultServer;
     closed = false;
+    closing = null;
     constructor(session, defaultServer) {
         this.session = session;
         this.defaultServer = defaultServer;
@@ -254,18 +255,16 @@ export class CompressorProxy {
         return (await this.invokeWrapper(wrapper, { tool_name: tool, tool_input: toolInput })).text;
     }
     close() {
-        if (this.closed) {
-            return;
+        if (this.closing) {
+            return this.closing;
         }
         this.closed = true;
-        try {
-            this.session.close();
-        }
-        finally {
-            const onClose = proxyCloseCallbacks.get(this);
-            proxyCloseCallbacks.delete(this);
-            onClose?.();
-        }
+        const onClose = proxyCloseCallbacks.get(this);
+        proxyCloseCallbacks.delete(this);
+        onClose?.();
+        const closing = this.session.close();
+        this.closing = closing.catch(() => { });
+        return closing;
     }
     toExecutableTools() {
         const result = {};
@@ -394,7 +393,7 @@ export class CompressorClient {
         }
         const proxy = this.proxy;
         try {
-            proxy?.close();
+            await proxy?.close();
         }
         finally {
             if (this.proxy === proxy) {

package/dist/rust_core.d.ts

@@ -83,9 +83,10 @@ export interface CompressedSessionInfo {
 }
 export declare class CompressedSession {
     private readonly nativeSession;
+    private closing;
     constructor(nativeSession: NativeCompressedSession);
     info(): CompressedSessionInfo;
-    close(): void;
+    close(): Promise<void>;
     updateAuthProviderHeaders(providerIndex: number, headers: Record<string, string>): void;
 }
 export declare function startCompressedSession(config: CompressedSessionConfig, backends: BackendConfig[]): Promise<CompressedSession>;

package/dist/rust_core.js

@@ -54,6 +54,7 @@ export function generateClientArtifactFiles(kind, config) {
 }
 export class CompressedSession {
     nativeSession;
+    closing = null;
     constructor(nativeSession) {
         this.nativeSession = nativeSession;
     }
@@ -61,7 +62,12 @@ export class CompressedSession {
         return JSON.parse(this.nativeSession.infoJson());
     }
     close() {
-        this.nativeSession.close();
+        if (this.closing) {
+            return this.closing;
+        }
+        const closing = this.nativeSession.close();
+        this.closing = closing.catch(() => { });
+        return closing;
     }
     updateAuthProviderHeaders(providerIndex, headers) {
         this.nativeSession.updateAuthProviderHeadersJson(providerIndex, stringify(headers));

package/native/index.d.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 export declare class NativeCompressedSession {
   infoJson(): string
-  close(): void
+  close(): Promise<void>
   updateAuthProviderHeadersJson(providerIndex: number, headersJson: string): void
 }
 
@@ -36,6 +36,14 @@ export declare function renderCliSubcommandHelpJson(cliName: string, toolJson: s
 
 export declare function renderCliTopLevelHelpJson(command: string, cliName: string, toolsJson: string): string
 
+/**
+ * Run the full `mcp-compressor` CLI in-process and return its exit code.
+ *
+ * Blocks the calling thread until the CLI exits, so the npm `mcp-compressor`
+ * bin works without a separately installed Rust binary. Not for library use.
+ */
+export declare function runCliJson(argvJson: string, version?: string | undefined | null): number
+
 export declare function startCompressedSessionFromMcpConfigJson(configJson: string, mcpConfigJson: string): Promise<NativeCompressedSession>
 
 export declare function startCompressedSessionJson(configJson: string, backendsJson: string): Promise<NativeCompressedSession>

package/native/index.js

@@ -592,6 +592,7 @@ module.exports.parseToolArgvJson = nativeBinding.parseToolArgvJson
 module.exports.rememberOauthBackendJson = nativeBinding.rememberOauthBackendJson
 module.exports.renderCliSubcommandHelpJson = nativeBinding.renderCliSubcommandHelpJson
 module.exports.renderCliTopLevelHelpJson = nativeBinding.renderCliTopLevelHelpJson
+module.exports.runCliJson = nativeBinding.runCliJson
 module.exports.startCompressedSessionFromMcpConfigJson = nativeBinding.startCompressedSessionFromMcpConfigJson
 module.exports.startCompressedSessionJson = nativeBinding.startCompressedSessionJson
 module.exports.startCompressedSessionWithProviderBackendsJson = nativeBinding.startCompressedSessionWithProviderBackendsJson

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlassian/mcp-compressor",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "TypeScript MCP server wrapper for reducing tokens consumed by MCP tools.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/atlassian-labs/mcp-compressor",