@atlassian/mcp-compressor 0.32.1 → 0.33.1

package/README.md

@@ -72,7 +72,7 @@ atlassian search-confluence --query oauth
 atlassian get-jira-issue --issue-url https://jira.example.com/browse/PROJ-123
 ```
 
-TOON output formatting is automatically enabled in CLI mode.
+Tool output is returned verbatim in CLI mode. Pass `--toonify` to opt in to TOON conversion of JSON, CSV and YAML results.
 
 ### Bash mode
 

package/dist/cli.js

@@ -61,15 +61,14 @@ 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.")
+        "server via CLI.")
         .option("--cli-port <port>", "Port for the local CLI bridge HTTP server (default: random free port).")
         .option("--just-bash", "Start in just-bash mode: expose a single 'bash' MCP tool powered by\n" +
         "just-bash, with all backend server tools available as custom commands.\n" +
-        "Requires the 'just-bash' package to be installed. --toonify is\n" +
-        "automatically enabled in this mode.")
+        "Requires the 'just-bash' package to be installed.")
         .option("--include-tool <tool>", "Wrapped server tool name to expose. Can be used multiple times.\n" +
         "If omitted, all tools are included.", collect, [])
         .option("--exclude-tool <tool>", "Wrapped server tool name to hide. Can be used multiple times.", collect, []);
@@ -85,7 +84,7 @@ function parseCliArgsWithOptions(argv, parseOptions = {}) {
     const backend = parseBackendArg(program.args);
     const justBash = parsedOptions.justBash ?? false;
     const cliMode = parsedOptions.cliMode ?? false;
-    const toonify = (parsedOptions.toonify ?? false) || cliMode || justBash;
+    const toonify = parsedOptions.toonify ?? false;
     return {
         backend,
         justBash,

package/dist/native.d.ts

@@ -20,7 +20,7 @@ export interface NativeCore {
     listOauthCredentialsJson(): string;
     clearOauthCredentialsJson(target?: string | null): string;
     startCompressedSessionJson(configJson: string, backendsJson: string): Promise<NativeCompressedSession>;
-    startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: 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 {

package/dist/native_client.d.ts

@@ -54,13 +54,24 @@ 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;
-    private readonly authProviders;
     private closed;
-    constructor(session: CompressedSession, defaultServer: string | null, authProviders?: AuthProvider[]);
-    private refreshAuthProviders;
+    constructor(session: CompressedSession, defaultServer: string | null);
     info(): CompressedSessionInfo;
     get bridgeUrl(): string;
     get token(): string;
@@ -87,10 +98,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

@@ -46,7 +46,7 @@ async function normalizeServersWithProviders(servers) {
     for (const [name, config] of Object.entries(servers)) {
         if (typeof config === "object" && config !== null && "url" in config) {
             const provider = providerFromConfig(config);
-            const backend = await sdkObjectToNative(name, config, { includeProvider: true });
+            const backend = await sdkObjectToNative(name, config, { includeProvider: provider === undefined });
             if (provider !== undefined) {
                 backend.providerIndex = providers.length;
                 providers.push(provider);
@@ -152,25 +152,38 @@ 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;
-    authProviders;
     closed = false;
-    constructor(session, defaultServer, authProviders = []) {
+    constructor(session, defaultServer) {
         this.session = session;
         this.defaultServer = defaultServer;
-        this.authProviders = authProviders;
-    }
-    async refreshAuthProviders() {
-        await Promise.all(this.authProviders.map(async (provider, index) => {
-            const headers = await provider();
-            const materialized = {};
-            for (const [key, value] of Object.entries(headers)) {
-                materialized[key] = String(value);
-            }
-            this.session.updateAuthProviderHeaders(index, materialized);
-        }));
     }
     info() {
         return this.session.info();
@@ -208,7 +221,6 @@ export class CompressorProxy {
         if (this.closed) {
             throw new Error("Compressor proxy is closed");
         }
-        await this.refreshAuthProviders();
         const response = await fetch(`${this.bridgeUrl}/exec`, {
             method: "POST",
             headers: {
@@ -242,8 +254,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 +307,9 @@ export class CompressorProxy {
 export class CompressorClient {
     options;
     session = null;
+    proxy = null;
+    connectPromise = null;
+    closingPromise = null;
     mode;
     authProviders = [];
     constructor(options) {
@@ -292,9 +317,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 +353,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());
+            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/dist/rust_core.js

@@ -88,13 +88,19 @@ export async function startCompressedSession(config, backends) {
     const session = await loadNativeCore().startCompressedSessionJson(stringify(toNativeSessionConfig(config)), stringify(backends.map(toNativeBackendConfig)));
     return new CompressedSession(session);
 }
+async function materializeAuthProviderHeaders(providers) {
+    return Promise.all(providers.map(async (provider) => {
+        const headers = await provider();
+        return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, String(value)]));
+    }));
+}
 export async function startCompressedSessionWithAuthProviders(config, backends, providers) {
     const nativeBackends = backends.map((backend) => ({
         ...toNativeBackendConfig(backend),
         provider_index: backend.providerIndex ?? null,
     }));
-    const initialHeaders = await Promise.all(providers.map((provider) => provider()));
-    const session = await loadNativeCore().startCompressedSessionWithProviderBackendsJson(stringify(toNativeSessionConfig(config)), stringify(nativeBackends), stringify(initialHeaders));
+    const initialHeaders = await materializeAuthProviderHeaders(providers);
+    const session = await loadNativeCore().startCompressedSessionWithProviderBackendsJson(stringify(toNativeSessionConfig(config)), stringify(nativeBackends), stringify(initialHeaders), async () => stringify(await materializeAuthProviderHeaders(providers)));
     return new CompressedSession(session);
 }
 export async function startCompressedSessionFromMcpConfig(config, mcpConfigJson) {

package/dist/transforms.d.ts

@@ -3,10 +3,16 @@ import { type JustBashCommandRegistration } from "./just_bash_commands.js";
 export interface TransformToolOptions {
     serverName?: string;
 }
-export interface TransformToolsForJustBashOptions extends TransformToolOptions {
-    bash: unknown;
-}
 export interface PlanToolsForJustBashOptions extends TransformToolOptions {
+    /**
+     * Convert JSON/CSV/YAML tool results to TOON before writing them to stdout.
+     * Defaults to ``false`` so Just Bash output matches the generated CLI byte for
+     * byte (and stays pipeable into tools such as ``jq``).
+     */
+    toonify?: boolean;
+}
+export interface TransformToolsForJustBashOptions extends PlanToolsForJustBashOptions {
+    bash: unknown;
 }
 export interface JustBashTransformResult {
     tools: Record<string, ExecutableTool>;

package/dist/transforms.js

@@ -6,7 +6,7 @@ export function planToolsForJustBash(tools, options = {}) {
     const serverName = normalizeServerName(options.serverName);
     const toolSpecs = executableToolsToSpecs(tools);
     const plan = buildHostTransformPlan({ kind: "just-bash", serverName, tools: toolSpecs });
-    const registrations = createJustBashCommandRegistrations((plan.justBash?.commands ?? []).map((command) => justBashSource(serverName, command.commandName, command.backendToolName, tools)));
+    const registrations = createJustBashCommandRegistrations((plan.justBash?.commands ?? []).map((command) => justBashSource(serverName, command.commandName, command.backendToolName, tools, options.toonify ?? false)));
     return {
         registrations,
         tools: helpTools({
@@ -38,7 +38,7 @@ export async function transformToolsForCliMode(tools, options = {}) {
         commandName: serverName,
     });
 }
-function justBashSource(serverName, commandName, backendToolName, tools) {
+function justBashSource(serverName, commandName, backendToolName, tools, toonify) {
     const tool = tools[backendToolName];
     if (tool === undefined) {
         throw new Error(`missing Just Bash backend tool: ${backendToolName}`);
@@ -49,7 +49,7 @@ function justBashSource(serverName, commandName, backendToolName, tools) {
         backendToolName,
         helpToolName: `${serverName}_help`,
         tool: executableToolToSpec(backendToolName, tool),
-        invoke: async (input) => normalizeHostToolResult(await tool.execute(input), true),
+        invoke: async (input) => normalizeHostToolResult(await tool.execute(input), toonify),
     };
 }
 async function generatedTransform(tools, options) {

package/native/index.d.ts

@@ -40,4 +40,4 @@ export declare function startCompressedSessionFromMcpConfigJson(configJson: stri
 
 export declare function startCompressedSessionJson(configJson: string, backendsJson: string): Promise<NativeCompressedSession>
 
-export declare function startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: string): Promise<NativeCompressedSession>
+export declare function startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: string, refreshProviders: RefreshProviders): Promise<NativeCompressedSession>

package/package.json

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