@atlassian/mcp-compressor 0.21.3 → 0.22.1

package/dist/local_tool_bridge.js

@@ -1,4 +1,4 @@
-import { stringifyToolResult } from "./tool_specs.js";
+import { normalizeHostToolResult } from "./rust_core.js";
 export async function startLocalToolBridge(tools) {
     const http = await import("node:http");
     const token = crypto.randomUUID();
@@ -28,7 +28,7 @@ export async function startLocalToolBridge(tools) {
             const result = await tool.execute(body.input ?? body.tool_input ?? {});
             response
                 .writeHead(200, { "content-type": "application/json" })
-                .end(JSON.stringify({ result: stringifyToolResult(result) }));
+                .end(JSON.stringify({ result: normalizeHostToolResult(result, false) }));
         }
         catch (error) {
             response

package/dist/native.d.ts

@@ -10,6 +10,8 @@ export interface NativeCore {
     parseToolArgvJson(toolJson: string, argvJson: string): string;
     generateClientArtifactsJson(kind: string, configJson: string): string;
     generateClientArtifactFilesJson(kind: string, configJson: string): string;
+    buildHostTransformPlanJson(configJson: string): string;
+    normalizeHostToolResultJson(valueJson: string, toonify: boolean): string;
     normalizeServersJson(serversJson: string): string;
     parseMcpConfigJson(configJson: string): string;
     rememberOauthBackendJson(backendUri: string, backendName: string, storeDir: string): void;

package/dist/rust_core.d.ts

@@ -100,3 +100,34 @@ export interface OAuthStoreEntry {
 }
 export declare function listOAuthCredentials(): OAuthStoreEntry[];
 export declare function clearOAuthCredentials(target?: string | null): string[];
+export interface HostTransformPlanConfig {
+    kind: ClientArtifactKind | "just-bash";
+    serverName: string;
+    tools: ToolSpec[];
+    outputDir?: string;
+    commandName?: string;
+    bridgeUrl?: string;
+    token?: string;
+    sessionPid?: number;
+}
+export interface HostTransformPlan {
+    helpToolName: string;
+    helpDescription: string;
+    outputDir?: string;
+    files: Record<string, string>;
+    paths: string[];
+    environment: Record<string, string>;
+    justBash?: {
+        providerName: string;
+        commandName: string;
+        helpToolName: string;
+        commands: Array<{
+            commandName: string;
+            backendToolName: string;
+            description?: string;
+            inputSchema: unknown;
+        }>;
+    };
+}
+export declare function buildHostTransformPlan(config: HostTransformPlanConfig): HostTransformPlan;
+export declare function normalizeHostToolResult(value: unknown, toonify: boolean): string;

package/dist/rust_core.js

@@ -107,3 +107,18 @@ export function listOAuthCredentials() {
 export function clearOAuthCredentials(target) {
     return JSON.parse(loadNativeCore().clearOauthCredentialsJson(target ?? null));
 }
+export function buildHostTransformPlan(config) {
+    return JSON.parse(loadNativeCore().buildHostTransformPlanJson(stringify({
+        kind: config.kind,
+        serverName: config.serverName,
+        tools: config.tools.map(toNativeTool),
+        outputDir: config.outputDir,
+        commandName: config.commandName,
+        bridgeUrl: config.bridgeUrl,
+        token: config.token,
+        sessionPid: config.sessionPid,
+    })));
+}
+export function normalizeHostToolResult(value, toonify) {
+    return loadNativeCore().normalizeHostToolResultJson(stringify(value), toonify);
+}

package/dist/tool_specs.js

@@ -19,10 +19,19 @@ export function normalizeServerName(name) {
 export function stringifyToolResult(value) {
     if (typeof value === "string")
         return value;
-    const mcpText = stringifyMcpTextContent(value);
+    const unwrapped = unwrapSingleResultWrapper(value);
+    if (typeof unwrapped === "string")
+        return unwrapped;
+    const mcpText = stringifyMcpTextContent(unwrapped);
     if (mcpText !== undefined)
         return mcpText;
-    return JSON.stringify(value);
+    return JSON.stringify(unwrapped);
+}
+function unwrapSingleResultWrapper(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const entries = Object.entries(value);
+    return entries.length === 1 && entries[0]?.[0] === "result" ? entries[0][1] : value;
 }
 function stringifyMcpTextContent(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))

package/dist/transforms.d.ts

@@ -1,5 +1,4 @@
 import type { ExecutableTool } from "./adapters.js";
-import { type GeneratedBridgeClientArtifactsResult } from "./generated_clients.js";
 import { type JustBashCommandRegistration } from "./just_bash_commands.js";
 export interface TransformToolOptions {
     serverName?: string;
@@ -19,7 +18,12 @@ export interface TransformToolsForCodeModeOptions extends TransformToolOptions {
 export interface TransformToolsForCliModeOptions extends TransformToolOptions {
     outputDir?: string;
 }
-export interface GeneratedToolTransformResult extends GeneratedBridgeClientArtifactsResult {
+export interface GeneratedToolTransformResult {
+    paths: string[];
+    files: Record<string, string>;
+    environment: Record<string, string>;
+    bridgeUrl: string;
+    token: string;
     tools: Record<string, ExecutableTool>;
     close(): void;
 }

package/dist/transforms.js

@@ -1,24 +1,19 @@
-import { generateClientFromBridge, } from "./generated_clients.js";
 import { createJustBashCommandRegistrations, installJustBashRegistrations, } from "./just_bash_commands.js";
 import { startLocalToolBridge } from "./local_tool_bridge.js";
-import { maybeToonifyOutput } from "./rust_core.js";
-import { executableToolToSpec, executableToolsToSpecs, normalizeServerName, stringifyToolResult, } from "./tool_specs.js";
+import { buildHostTransformPlan, normalizeHostToolResult, } from "./rust_core.js";
+import { executableToolToSpec, executableToolsToSpecs, normalizeServerName } from "./tool_specs.js";
 export function transformToolsForJustBash(tools, options) {
     const serverName = normalizeServerName(options.serverName);
-    const registrations = createJustBashCommandRegistrations(Object.entries(tools).map(([name, tool]) => justBashSource(serverName, name, tool)));
+    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)));
     installJustBashRegistrations(options.bash, registrations);
-    const helpDescription = shellToolHelpDescription({
-        command: serverName,
-        cliName: serverName,
-        tools: executableToolsToSpecs(tools),
-        commandNameForTool: cliSubcommandName,
-    });
     return {
         registrations,
         tools: helpTools({
-            serverName,
-            description: helpDescription,
-            output: helpDescription,
+            name: plan.helpToolName,
+            description: plan.helpDescription,
+            output: plan.helpDescription,
         }),
     };
 }
@@ -32,158 +27,59 @@ export async function transformToolsForCodeMode(tools, options) {
 }
 export async function transformToolsForCliMode(tools, options = {}) {
     const serverName = normalizeServerName(options.serverName);
-    const output = options.outputDir === undefined ? defaultCliOutputDir() : { outputDir: options.outputDir };
     return generatedTransform(tools, {
         kind: "cli",
         serverName,
-        outputDir: output.outputDir,
+        outputDir: options.outputDir,
         commandName: serverName,
     });
 }
-function justBashSource(serverName, name, tool) {
+function justBashSource(serverName, commandName, backendToolName, tools) {
+    const tool = tools[backendToolName];
+    if (tool === undefined) {
+        throw new Error(`missing Just Bash backend tool: ${backendToolName}`);
+    }
     return {
         providerName: serverName,
-        commandName: `${serverName}_${name}`,
-        backendToolName: name,
+        commandName,
+        backendToolName,
         helpToolName: `${serverName}_help`,
-        tool: executableToolToSpec(name, tool),
-        invoke: async (input) => maybeToonifyOutput(stringifyToolResult(await tool.execute(input))),
+        tool: executableToolToSpec(backendToolName, tool),
+        invoke: async (input) => normalizeHostToolResult(await tool.execute(input), true),
     };
 }
 async function generatedTransform(tools, options) {
     const bridge = await startLocalToolBridge(tools);
-    const generated = generateClientFromBridge({
-        kind: options.kind,
-        name: options.serverName,
-        bridgeUrl: bridge.bridgeUrl,
-        token: bridge.token,
-        tools: executableToolsToSpecs(tools),
-        outputDir: options.outputDir,
-    });
-    const helpDescription = generatedHelpDescription({
+    const plan = buildHostTransformPlan({
         kind: options.kind,
         serverName: options.serverName,
+        tools: executableToolsToSpecs(tools),
         outputDir: options.outputDir,
-        files: Object.keys(generated.files),
         commandName: options.commandName,
-        tools: executableToolsToSpecs(tools),
+        bridgeUrl: bridge.bridgeUrl,
+        token: bridge.token,
     });
     return {
-        ...generated,
+        paths: plan.paths,
+        files: plan.files,
+        environment: plan.environment,
+        bridgeUrl: bridge.bridgeUrl,
+        token: bridge.token,
         tools: helpTools({
-            serverName: options.serverName,
-            description: helpDescription,
-            output: helpDescription,
+            name: plan.helpToolName,
+            description: plan.helpDescription,
+            output: plan.helpDescription,
         }),
         close: () => bridge.close(),
     };
 }
 function helpTools(options) {
-    const name = `${options.serverName}_help`;
     return {
-        [name]: {
-            name,
+        [options.name]: {
+            name: options.name,
             description: options.description,
             inputSchema: { type: "object", properties: {} },
             execute: async () => options.output,
         },
     };
 }
-function generatedHelpDescription(options) {
-    if (options.kind === "cli") {
-        const command = options.commandName ?? `${options.outputDir}/${options.serverName}`;
-        return cliHelpDescription(command, options.serverName, options.tools);
-    }
-    return codeHelpDescription(options);
-}
-function cliHelpDescription(command, cliName, tools) {
-    return shellToolHelpDescription({
-        command,
-        cliName,
-        tools,
-        commandNameForTool: cliSubcommandName,
-    });
-}
-function shellToolHelpDescription(options) {
-    return [
-        `Functionality associated with the ${options.cliName} toolset is provided via the \`${options.command}\` CLI. Do not call this tool - use the CLI instead.`,
-        `${options.cliName} - the ${options.cliName} toolset`,
-        "",
-        "When relevant, outputs from this CLI will prefer using the TOON format for more efficient representation of data.",
-        "",
-        "USAGE:",
-        `  ${options.command} <subcommand> [options]`,
-        "",
-        "SUBCOMMANDS:",
-        ...formatSubcommands(options.tools, options.commandNameForTool),
-        "",
-        `Run '${options.command} --help' in the shell for usage.`,
-        `Run '${options.command} <subcommand> --help' for per-command help.`,
-        `Run '${options.command} <subcommand> [options]' to invoke a tool.`,
-    ].join("\n");
-}
-function formatSubcommands(tools, commandNameForTool) {
-    const maxNameLength = Math.max(...tools.map((tool) => commandNameForTool(tool.name).length), 0);
-    return tools.map((tool) => {
-        const subcommand = commandNameForTool(tool.name);
-        const description = compactDescription(tool.description ?? undefined);
-        return `  ${subcommand.padEnd(maxNameLength + 2)}${description}`.trimEnd();
-    });
-}
-function cliSubcommandName(toolName) {
-    return toolName.replaceAll("_", "-");
-}
-function compactDescription(description) {
-    return (description ?? "").replace(/\s+/g, " ").trim();
-}
-function codeHelpDescription(options) {
-    const language = options.kind === "python" ? "Python" : "TypeScript";
-    const languageLower = options.kind === "python" ? "python" : "typescript";
-    const moduleName = options.kind === "python" ? `${options.serverName}.py` : `${options.serverName}.ts`;
-    const functions = formatCodeFunctions(options.kind, options.tools);
-    const details = options.kind === "python"
-        ? [
-            "For details on a specific function, run:",
-            "```python",
-            `from ${options.serverName} import <function>`,
-            "print(help(<function>))",
-            "```",
-        ]
-        : [
-            "For details on a specific function, inspect the generated TypeScript declarations or editor hover documentation.",
-            `Primary declarations: ${options.outputDir}/${options.serverName}.d.ts`,
-        ];
-    return [
-        `Functionality associated with the ${options.serverName} toolset is provided via a ${language} module. Do not call this tool - import and use the ${languageLower} functionality instead.`,
-        `${options.serverName} - the ${options.serverName} toolset`,
-        "",
-        `${language} source code is available in ${options.outputDir}/${moduleName}`,
-        "",
-        "Available functions:",
-        ...functions,
-        "",
-        ...details,
-    ].join("\n");
-}
-function formatCodeFunctions(kind, tools) {
-    const names = tools.map((tool) => (kind === "python" ? tool.name : snakeToCamel(tool.name)));
-    const maxNameLength = Math.max(...names.map((name) => name.length), 0);
-    return tools.map((tool, index) => {
-        const name = names[index] ?? tool.name;
-        return `  ${name.padEnd(maxNameLength + 2)}${compactDescription(tool.description ?? undefined)}`.trimEnd();
-    });
-}
-function snakeToCamel(name) {
-    return name.replace(/[_-]([a-zA-Z0-9])/g, (_match, char) => char.toUpperCase());
-}
-function defaultCliOutputDir() {
-    const envDir = process.env.MCP_COMPRESSOR_CLI_OUTPUT_DIR;
-    if (envDir !== undefined && envDir.length > 0) {
-        return { outputDir: envDir };
-    }
-    const home = process.env.HOME;
-    if (home !== undefined && home.length > 0) {
-        return { outputDir: `${home}/.local/bin` };
-    }
-    return { outputDir: "./dist" };
-}

package/native/index.d.ts

@@ -6,6 +6,8 @@ export declare class NativeCompressedSession {
   updateAuthProviderHeadersJson(providerIndex: number, headersJson: string): void
 }
 
+export declare function buildHostTransformPlanJson(configJson: string): string
+
 export declare function clearOauthCredentialsJson(target?: string | undefined | null): string
 
 export declare function compressToolListingJson(level: string, toolsJson: string): string
@@ -20,6 +22,8 @@ export declare function listOauthCredentialsJson(): string
 
 export declare function maybeToonifyOutputJson(output: string): string
 
+export declare function normalizeHostToolResultJson(valueJson: string, toonify: boolean): string
+
 export declare function normalizeServersJson(serversJson: string): string
 
 export declare function parseMcpConfigJson(configJson: string): string

package/native/index.js

@@ -577,6 +577,7 @@ if (!nativeBinding) {
 
 module.exports = nativeBinding
 module.exports.NativeCompressedSession = nativeBinding.NativeCompressedSession
+module.exports.buildHostTransformPlanJson = nativeBinding.buildHostTransformPlanJson
 module.exports.clearOauthCredentialsJson = nativeBinding.clearOauthCredentialsJson
 module.exports.compressToolListingJson = nativeBinding.compressToolListingJson
 module.exports.formatToolSchemaResponseJson = nativeBinding.formatToolSchemaResponseJson
@@ -584,6 +585,7 @@ module.exports.generateClientArtifactFilesJson = nativeBinding.generateClientArt
 module.exports.generateClientArtifactsJson = nativeBinding.generateClientArtifactsJson
 module.exports.listOauthCredentialsJson = nativeBinding.listOauthCredentialsJson
 module.exports.maybeToonifyOutputJson = nativeBinding.maybeToonifyOutputJson
+module.exports.normalizeHostToolResultJson = nativeBinding.normalizeHostToolResultJson
 module.exports.normalizeServersJson = nativeBinding.normalizeServersJson
 module.exports.parseMcpConfigJson = nativeBinding.parseMcpConfigJson
 module.exports.parseToolArgvJson = nativeBinding.parseToolArgvJson

package/package.json

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