@atlassian/mcp-compressor 0.32.1 → 0.33.0

package/dist/cli.js

@@ -61,7 +61,7 @@ function buildProgram(options = {}) {
         "invoke_tool, list_tools). The name will be sanitized to conform to MCP\n" +
         "tool name specifications (only A-Z, a-z, 0-9, _, -, .).")
         .option("-l, --log-level <level>", "The logging level.", "error")
-        .option("--toonify", "Convert JSON tool responses to TOON format automatically.")
+        .option("--toonify", "Convert JSON, CSV and YAML tool responses to TOON format automatically.")
         .option("--cli-mode", "Start in CLI mode: expose a single help MCP tool, start a local HTTP\n" +
         "bridge, and generate a shell script for interacting with the wrapped\n" +
         "server via CLI. --toonify is automatically enabled in this mode.")

package/dist/native_client.d.ts

@@ -54,6 +54,19 @@ export interface GeneratedCodeClient {
     environment: Record<string, string>;
 }
 export declare function normalizeServers(servers: NativeServersInput): Promise<NormalizedBackendConfig[] | string>;
+/**
+ * Hand a freshly started native session to `build`, closing the session if
+ * `build` throws.
+ *
+ * A started session owns backend processes and sockets that are only reachable
+ * through the object `build` returns. Without this the session would leak for
+ * the lifetime of the host process whenever adoption failed.
+ *
+ * Internal; not part of the public package surface.
+ */
+export declare function adoptNativeSession<T>(session: {
+    close(): void;
+}, build: () => T): T;
 export declare class CompressorProxy {
     private readonly session;
     private readonly defaultServer;
@@ -87,10 +100,15 @@ export declare class CompressorProxy {
 export declare class CompressorClient {
     private readonly options;
     private session;
+    private proxy;
+    private connectPromise;
+    private closingPromise;
     private readonly mode;
     private authProviders;
     constructor(options: CompressorClientOptions);
     connect(): Promise<CompressorProxy>;
+    private startConnection;
     close(): Promise<void>;
+    private closeCurrentConnection;
     private defaultServer;
 }

package/dist/native_client.js

@@ -152,6 +152,31 @@ function transformMode(mode) {
         return "cli";
     return mode;
 }
+const proxyCloseCallbacks = new WeakMap();
+/**
+ * Hand a freshly started native session to `build`, closing the session if
+ * `build` throws.
+ *
+ * A started session owns backend processes and sockets that are only reachable
+ * through the object `build` returns. Without this the session would leak for
+ * the lifetime of the host process whenever adoption failed.
+ *
+ * Internal; not part of the public package surface.
+ */
+export function adoptNativeSession(session, build) {
+    try {
+        return build();
+    }
+    catch (error) {
+        try {
+            session.close();
+        }
+        catch {
+            // Closing a session that never became reachable is best effort.
+        }
+        throw error;
+    }
+}
 export class CompressorProxy {
     session;
     defaultServer;
@@ -242,8 +267,18 @@ export class CompressorProxy {
         return (await this.invokeWrapper(wrapper, { tool_name: tool, tool_input: toolInput })).text;
     }
     close() {
+        if (this.closed) {
+            return;
+        }
         this.closed = true;
-        this.session.close();
+        try {
+            this.session.close();
+        }
+        finally {
+            const onClose = proxyCloseCallbacks.get(this);
+            proxyCloseCallbacks.delete(this);
+            onClose?.();
+        }
     }
     toExecutableTools() {
         const result = {};
@@ -285,6 +320,9 @@ export class CompressorProxy {
 export class CompressorClient {
     options;
     session = null;
+    proxy = null;
+    connectPromise = null;
+    closingPromise = null;
     mode;
     authProviders = [];
     constructor(options) {
@@ -292,9 +330,32 @@ export class CompressorClient {
         this.mode = options.mode ?? "compressed";
     }
     async connect() {
-        if (this.session) {
-            return new CompressorProxy(this.session, this.defaultServer(), this.authProviders);
+        if (this.closingPromise) {
+            try {
+                await this.closingPromise;
+            }
+            catch {
+                // The close caller receives the error; cleared state can reconnect independently.
+            }
+        }
+        if (this.proxy) {
+            return this.proxy;
         }
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+        const connection = this.startConnection();
+        this.connectPromise = connection;
+        try {
+            return await connection;
+        }
+        finally {
+            if (this.connectPromise === connection) {
+                this.connectPromise = null;
+            }
+        }
+    }
+    async startConnection() {
         const normalized = await normalizeServersWithProviders(this.options.servers);
         const config = {
             compressionLevel: this.options.compressionLevel ?? "medium",
@@ -305,17 +366,55 @@ export class CompressorClient {
             transformMode: transformMode(this.mode),
         };
         this.authProviders = typeof normalized === "string" ? [] : normalized.providers;
-        this.session =
-            typeof normalized === "string"
-                ? await startCompressedSessionFromMcpConfig(config, normalized)
-                : normalized.providers.length > 0
-                    ? await startCompressedSessionWithAuthProviders(config, normalized.backends, normalized.providers)
-                    : await startCompressedSession(config, normalized.backends);
-        return new CompressorProxy(this.session, this.defaultServer(), this.authProviders);
-    }
-    async close() {
-        this.session?.close();
-        this.session = null;
+        const session = typeof normalized === "string"
+            ? await startCompressedSessionFromMcpConfig(config, normalized)
+            : normalized.providers.length > 0
+                ? await startCompressedSessionWithAuthProviders(config, normalized.backends, normalized.providers)
+                : await startCompressedSession(config, normalized.backends);
+        const proxy = adoptNativeSession(session, () => {
+            const adopted = new CompressorProxy(session, this.defaultServer(), this.authProviders);
+            proxyCloseCallbacks.set(adopted, () => {
+                if (this.proxy === adopted) {
+                    this.proxy = null;
+                    this.session = null;
+                }
+            });
+            return adopted;
+        });
+        this.session = session;
+        this.proxy = proxy;
+        return proxy;
+    }
+    close() {
+        if (!this.closingPromise) {
+            const closing = this.closeCurrentConnection();
+            let trackedClosing;
+            trackedClosing = closing.finally(() => {
+                if (this.closingPromise === trackedClosing) {
+                    this.closingPromise = null;
+                }
+            });
+            this.closingPromise = trackedClosing;
+        }
+        return this.closingPromise;
+    }
+    async closeCurrentConnection() {
+        try {
+            await this.connectPromise;
+        }
+        catch {
+            // A failed connection has no native session to release.
+        }
+        const proxy = this.proxy;
+        try {
+            proxy?.close();
+        }
+        finally {
+            if (this.proxy === proxy) {
+                this.proxy = null;
+                this.session = null;
+            }
+        }
     }
     defaultServer() {
         const servers = this.options.servers;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlassian/mcp-compressor",
-  "version": "0.32.1",
+  "version": "0.33.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",