@atlassian/mcp-compressor 0.33.2 → 0.35.0

package/dist/just_bash_commands.js

@@ -29,15 +29,21 @@ export function createJustBashCommandRegistrations(sources) {
                     }
                     const source = bySubcommand.get(subcommand);
                     if (source === undefined) {
-                        throw new Error(`Unknown ${providerName} subcommand: ${subcommand}`);
+                        return usageFailure(`parse error: unknown subcommand: ${subcommand}`, providerName);
                     }
                     // Per-subcommand help must match the generated CLI's rich `--help`
                     // output, so render it from the shared Rust renderer.
                     if (toolArgs.includes("--help") || toolArgs.includes("-h")) {
                         return output(renderCliSubcommandHelp(providerName, source.tool));
                     }
-                    const parsedInput = parseToolArgv(source.tool, toolArgs);
-                    const toolInput = normalizeStructuredArgValues(source.tool.inputSchema, parsedInput);
+                    let toolInput;
+                    try {
+                        const parsedInput = parseToolArgv(source.tool, toolArgs);
+                        toolInput = normalizeStructuredArgValues(source.tool.inputSchema, parsedInput);
+                    }
+                    catch (error) {
+                        return usageFailure(errorMessage(error), `${providerName} ${subcommand}`);
+                    }
                     return output(await source.invoke(toolInput));
                 }
                 catch (error) {
@@ -63,7 +69,21 @@ export function installJustBashRegistrations(bash, registrations) {
 function output(stdout) {
     return { stdout: `${stdout}\n`, stderr: "", exitCode: 0 };
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** A failed tool call: the tool's own message, exit 1. */
 function failure(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { stdout: "", stderr: `${message}\n`, exitCode: 1 };
+    return { stdout: "", stderr: `${errorMessage(error)}\n`, exitCode: 1 };
+}
+/**
+ * A malformed invocation, reported exactly like the generated CLI script:
+ * the parser's message, a pointer to `--help`, and exit 2.
+ */
+function usageFailure(message, helpCommand) {
+    return {
+        stdout: "",
+        stderr: `${message}\nRun '${helpCommand} --help' for usage.\n`,
+        exitCode: 2,
+    };
 }

package/dist/local_tools.js

@@ -1,4 +1,4 @@
-import { compressToolListing, formatToolSchemaResponse } from "./rust_core.js";
+import { compressToolListing, formatToolSchemaResponse, normalizeHostToolResult, } from "./rust_core.js";
 import { stringifyToolResult } from "./tool_specs.js";
 function wrapperName(prefix, name) {
     return prefix ? `${prefix}_${name}` : name;
@@ -36,12 +36,10 @@ function validateRequiredToolInput(spec, toolInput) {
         JSON.stringify(spec.inputSchema, null, 2));
 }
 function normalizeResult(value, toonify) {
-    const json = stringifyToolResult(value);
     if (!toonify)
-        return json;
-    // Keep local compression dependency-light for now. Runtime MCP proxy paths use
-    // Rust TOON support; local in-process tools return JSON-compatible strings.
-    return json;
+        return stringifyToolResult(value);
+    // Same conversion the proxy and host transforms apply.
+    return normalizeHostToolResult(value, true);
 }
 export function compressTools(tools, options = {}) {
     const compressionLevel = options.compressionLevel ?? "medium";

package/package.json

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

package/dist/just_bash_transform.d.ts

@@ -1,75 +0,0 @@
-/**
- * AST-level pipe/redirection detection for just-bash custom commands.
- *
- * Registers a ``TransformPlugin`` that walks the parsed AST and injects
- * ``MCP_TOONIFY=true|false`` env-var prefixes onto each invocation of one
- * of our wrapper commands, based on whether its stdout is piped
- * (``cmd | jq``) or redirected (``cmd > out.json``).  The wrapper command
- * in ``bash_commands.ts`` reads ``ctx.env.MCP_TOONIFY`` to choose between
- * TOON and raw JSON output.  User-supplied ``MCP_TOONIFY=...`` prefixes
- * are preserved.
- */
-import type { Bash } from "just-bash";
-/** Env var injected into wrapper invocations: "true" -> TOON, "false" -> JSON. */
-export declare const MCP_TOONIFY_ENV_VAR = "MCP_TOONIFY";
-interface WordPart {
-    type: string;
-    value?: string;
-}
-interface WordNode {
-    type: "Word";
-    parts: WordPart[];
-}
-interface AssignmentNode {
-    type: "Assignment";
-    name: string;
-    value: WordNode | null;
-    append: boolean;
-    array: WordNode[] | null;
-}
-interface RedirectionNode {
-    type: "Redirection";
-    fd: number | null;
-    fdVariable?: string;
-    operator: string;
-    target: unknown;
-}
-interface SimpleCommandNode {
-    type: "SimpleCommand";
-    assignments: AssignmentNode[];
-    name: WordNode | null;
-    args: WordNode[];
-    redirections: RedirectionNode[];
-    line?: number;
-}
-interface PipelineNode {
-    type: "Pipeline";
-    commands: AnyCommandNode[];
-}
-interface StatementNode {
-    type: "Statement";
-    pipelines: PipelineNode[];
-}
-interface ScriptNode {
-    type: "Script";
-    statements: StatementNode[];
-}
-type AnyCommandNode = SimpleCommandNode | Record<string, unknown>;
-interface TransformInput {
-    ast: ScriptNode;
-    metadata: Record<string, unknown>;
-}
-interface TransformOutput {
-    ast: ScriptNode;
-    metadata?: Record<string, unknown>;
-}
-interface TransformPlugin {
-    transform(input: TransformInput): TransformOutput;
-}
-/** Build a ``TransformPlugin`` that injects ``MCP_TOONIFY`` prefixes (in-place AST mutation). */
-export declare function createPipingHintPlugin(customCommandNames: readonly string[]): TransformPlugin;
-/** Read ``MCP_TOONIFY`` from *env*, returning *defaultValue* if absent/invalid. */
-export declare function resolveToonifyFromEnv(env: Map<string, string> | Record<string, string> | undefined, defaultValue: boolean): boolean;
-/** Register :func:`createPipingHintPlugin` on *bash*. */
-export declare function installPipingHintPlugin(bash: Bash, customCommandNames: readonly string[]): void;
-export {};

package/dist/just_bash_transform.js

@@ -1,167 +0,0 @@
-/**
- * AST-level pipe/redirection detection for just-bash custom commands.
- *
- * Registers a ``TransformPlugin`` that walks the parsed AST and injects
- * ``MCP_TOONIFY=true|false`` env-var prefixes onto each invocation of one
- * of our wrapper commands, based on whether its stdout is piped
- * (``cmd | jq``) or redirected (``cmd > out.json``).  The wrapper command
- * in ``bash_commands.ts`` reads ``ctx.env.MCP_TOONIFY`` to choose between
- * TOON and raw JSON output.  User-supplied ``MCP_TOONIFY=...`` prefixes
- * are preserved.
- */
-/** Env var injected into wrapper invocations: "true" -> TOON, "false" -> JSON. */
-export const MCP_TOONIFY_ENV_VAR = "MCP_TOONIFY";
-/** Redirection operators that move stdout off the caller's pipe. */
-const OUTPUT_REDIR_OPERATORS = new Set([">", ">>", ">|", "&>", "&>>", "<>"]);
-// --- helpers ----------------------------------------------------------------
-function isLiteralPart(part) {
-    return part.type === "Literal" && typeof part.value === "string";
-}
-/** Return *cmd*'s literal name, or ``null`` for dynamic invocations. */
-function simpleCommandName(cmd) {
-    if (cmd.name === null) {
-        return null;
-    }
-    const pieces = [];
-    for (const part of cmd.name.parts) {
-        if (!isLiteralPart(part)) {
-            return null;
-        }
-        pieces.push(part.value);
-    }
-    const joined = pieces.join("");
-    return joined.length > 0 ? joined : null;
-}
-/** Return ``true`` if *cmd* redirects fd 1 (stdout) somewhere else. */
-function hasStdoutRedirection(cmd) {
-    for (const redir of cmd.redirections ?? []) {
-        if (!OUTPUT_REDIR_OPERATORS.has(redir.operator)) {
-            continue;
-        }
-        // fd defaults to 1 for >/>>/>|; &>/&>> always cover stdout.
-        if (redir.fd === null ||
-            redir.fd === 1 ||
-            redir.operator === "&>" ||
-            redir.operator === "&>>") {
-            return true;
-        }
-    }
-    return false;
-}
-function makeAssignment(name, value) {
-    return {
-        type: "Assignment",
-        name,
-        value: { type: "Word", parts: [{ type: "Literal", value }] },
-        append: false,
-        array: null,
-    };
-}
-function isSimpleCommand(node) {
-    return (typeof node === "object" &&
-        node !== null &&
-        node.type === "SimpleCommand");
-}
-function injectToonify(cmd, toonify) {
-    // Preserve user-set MCP_TOONIFY assignments.
-    for (const assignment of cmd.assignments ?? []) {
-        if (assignment.name === MCP_TOONIFY_ENV_VAR) {
-            return;
-        }
-    }
-    cmd.assignments = [
-        makeAssignment(MCP_TOONIFY_ENV_VAR, toonify ? "true" : "false"),
-        ...(cmd.assignments ?? []),
-    ];
-}
-function transformPipeline(pipeline, names) {
-    const n = pipeline.commands.length;
-    pipeline.commands.forEach((cmd, index) => {
-        if (isSimpleCommand(cmd)) {
-            const name = simpleCommandName(cmd);
-            if (name !== null && names.has(name)) {
-                const isLast = index === n - 1;
-                const isPiped = !isLast || hasStdoutRedirection(cmd);
-                injectToonify(cmd, !isPiped);
-            }
-        }
-        else {
-            transformCompound(cmd, names);
-        }
-    });
-}
-function transformStatements(statements, names) {
-    for (const stmt of statements) {
-        for (const pipeline of stmt.pipelines) {
-            transformPipeline(pipeline, names);
-        }
-    }
-}
-/** Recurse into compound nodes (``if``/``for``/``while``/subshell/etc.) by shape. */
-function transformCompound(node, names) {
-    for (const value of Object.values(node)) {
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                if (item && typeof item === "object") {
-                    const t = item.type;
-                    if (t === "Statement") {
-                        transformStatements(value, names);
-                        break;
-                    }
-                    if ("body" in item ||
-                        "condition" in item ||
-                        "patterns" in item ||
-                        "clauses" in item ||
-                        "elseBody" in item) {
-                        transformCompound(item, names);
-                    }
-                }
-            }
-        }
-        else if (value && typeof value === "object") {
-            transformCompound(value, names);
-        }
-    }
-}
-// --- public plugin factory --------------------------------------------------
-/** Build a ``TransformPlugin`` that injects ``MCP_TOONIFY`` prefixes (in-place AST mutation). */
-export function createPipingHintPlugin(customCommandNames) {
-    const names = new Set(customCommandNames);
-    return {
-        transform({ ast, metadata }) {
-            if (names.size === 0) {
-                return { ast, metadata };
-            }
-            transformStatements(ast.statements, names);
-            return { ast, metadata };
-        },
-    };
-}
-/** Read ``MCP_TOONIFY`` from *env*, returning *defaultValue* if absent/invalid. */
-export function resolveToonifyFromEnv(env, defaultValue) {
-    if (!env) {
-        return defaultValue;
-    }
-    let raw;
-    if (env instanceof Map) {
-        raw = env.get(MCP_TOONIFY_ENV_VAR);
-    }
-    else {
-        raw = env[MCP_TOONIFY_ENV_VAR];
-    }
-    if (raw === undefined) {
-        return defaultValue;
-    }
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === "true") {
-        return true;
-    }
-    if (normalized === "false") {
-        return false;
-    }
-    return defaultValue;
-}
-/** Register :func:`createPipingHintPlugin` on *bash*. */
-export function installPipingHintPlugin(bash, customCommandNames) {
-    bash.registerTransformPlugin(createPipingHintPlugin(customCommandNames));
-}