@atlassian/mcp-compressor 0.0.2

package/dist/native_client.js

@@ -0,0 +1,330 @@
+import { generateClientArtifacts, normalizeSdkServers, startCompressedSession, startCompressedSessionWithAuthProviders, startCompressedSessionFromMcpConfig, } from "./rust_core.js";
+function providerFromConfig(config) {
+    const provider = config.authProvider ?? config.auth_provider;
+    if (provider === undefined) {
+        return undefined;
+    }
+    if (typeof provider !== "function") {
+        throw new TypeError("authProvider must be a function");
+    }
+    return provider;
+}
+async function resolveAuthHeaders(config, options = {}) {
+    const headers = {};
+    const rawHeaders = config.headers;
+    if (rawHeaders && typeof rawHeaders === "object" && !Array.isArray(rawHeaders)) {
+        for (const [key, value] of Object.entries(rawHeaders)) {
+            headers[key] = String(value);
+        }
+    }
+    const provider = providerFromConfig(config);
+    if ((options.includeProvider ?? true) && provider !== undefined) {
+        const provided = await provider();
+        for (const [key, value] of Object.entries(provided)) {
+            headers[key] = String(value);
+        }
+    }
+    return headers;
+}
+async function normalizeServersWithProviders(servers) {
+    if (typeof servers === "string") {
+        const trimmed = servers.trim();
+        if (trimmed.startsWith("{")) {
+            return servers;
+        }
+        return { backends: [{ name: "default", commandOrUrl: servers }], providers: [] };
+    }
+    if (isLegacyBackendConfig(servers)) {
+        return {
+            backends: [await legacyBackendToNative("default", servers, { includeProvider: false })],
+            providers: [],
+        };
+    }
+    const backends = [];
+    const providers = [];
+    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 });
+            if (provider !== undefined) {
+                backend.providerIndex = providers.length;
+                providers.push(provider);
+            }
+            backends.push(backend);
+        }
+        else if (typeof config === "object" && config !== null && "command" in config) {
+            backends.push(await sdkObjectToNative(name, config, {
+                includeProvider: false,
+            }));
+        }
+        else {
+            const normalized = normalizeSdkServers({ [name]: config });
+            backends.push(normalized[0]);
+        }
+    }
+    return { backends, providers };
+}
+export async function normalizeServers(servers) {
+    if (typeof servers === "string") {
+        const trimmed = servers.trim();
+        if (trimmed.startsWith("{")) {
+            return servers;
+        }
+        return [{ name: "default", commandOrUrl: servers }];
+    }
+    if (isLegacyBackendConfig(servers)) {
+        return [await legacyBackendToNative("default", servers)];
+    }
+    const normalized = [];
+    for (const [name, config] of Object.entries(servers)) {
+        if (typeof config === "object" && config !== null && ("url" in config || "command" in config)) {
+            normalized.push(await sdkObjectToNative(name, config));
+        }
+        else {
+            normalized.push(...normalizeSdkServers({ [name]: config }));
+        }
+    }
+    return normalized;
+}
+function isLegacyBackendConfig(value) {
+    return (typeof value === "object" && value !== null && "type" in value && typeof value.type === "string");
+}
+async function sdkObjectToNative(name, config, options = {}) {
+    if ("url" in config) {
+        const args = [];
+        const headers = await resolveAuthHeaders(config, options);
+        for (const [key, value] of Object.entries(headers)) {
+            args.push("-H", `${key}=${value}`);
+        }
+        if (Object.keys(headers).length > 0 &&
+            !(Array.isArray(config.args) && config.args.includes("--auth"))) {
+            args.push("--auth", "explicit-headers");
+        }
+        if (Array.isArray(config.args)) {
+            args.push(...config.args.map(String));
+        }
+        const backend = {
+            name,
+            commandOrUrl: String(config.url),
+            args,
+        };
+        const oauthAppName = config.oauthAppName ?? config.oauth_app_name;
+        if (oauthAppName !== undefined) {
+            backend.oauth_app_name = String(oauthAppName);
+        }
+        return backend;
+    }
+    if ("command" in config) {
+        const backend = {
+            name,
+            commandOrUrl: String(config.command),
+            args: Array.isArray(config.args) ? config.args.map(String) : [],
+        };
+        const oauthAppName = config.oauthAppName ?? config.oauth_app_name;
+        if (oauthAppName !== undefined) {
+            backend.oauth_app_name = String(oauthAppName);
+        }
+        return backend;
+    }
+    throw new Error(`server ${name} must define command or url`);
+}
+async function legacyBackendToNative(name, backend, options = {}) {
+    if (backend.type === "stdio") {
+        return { name, commandOrUrl: backend.command, args: backend.args ?? [] };
+    }
+    const args = [];
+    const headers = await resolveAuthHeaders(backend, options);
+    if (Object.keys(headers).length > 0) {
+        for (const [key, value] of Object.entries(headers)) {
+            args.push("-H", `${key}=${value}`);
+        }
+        args.push("--auth", "explicit-headers");
+    }
+    return { name, commandOrUrl: backend.url, args };
+}
+function transformMode(mode) {
+    if (mode === "compressed")
+        return null;
+    if (mode === "bash")
+        return "just-bash";
+    if (mode === "python" || mode === "typescript")
+        return "cli";
+    return mode;
+}
+export class CompressorProxy {
+    session;
+    defaultServer;
+    authProviders;
+    closed = false;
+    constructor(session, defaultServer, authProviders = []) {
+        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();
+    }
+    get bridgeUrl() {
+        return this.info().bridge_url;
+    }
+    get token() {
+        return this.info().token;
+    }
+    get tools() {
+        return this.info().frontend_tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.input_schema,
+        }));
+    }
+    get justBashProviders() {
+        return this.info().just_bash_providers.map((provider) => ({
+            providerName: provider.provider_name,
+            helpToolName: provider.help_tool_name,
+            tools: provider.tools.map((command) => ({
+                commandName: command.command_name,
+                backendToolName: command.backendToolName ??
+                    command.backend_tool_name ??
+                    command.tool_name ??
+                    command.command_name,
+                description: command.description,
+                inputSchema: command.input_schema,
+                invokeToolName: command.invoke_tool_name,
+            })),
+        }));
+    }
+    async invokeWrapper(wrapperTool, toolInput) {
+        if (this.closed) {
+            throw new Error("Compressor proxy is closed");
+        }
+        await this.refreshAuthProviders();
+        const response = await fetch(`${this.bridgeUrl}/exec`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ tool: wrapperTool, input: toolInput }),
+        });
+        if (!response.ok) {
+            throw new Error(`Proxy invocation failed: ${response.status} ${await response.text()}`);
+        }
+        return { text: await response.text() };
+    }
+    schema(tool, options = {}) {
+        const server = options.server ?? this.defaultServer;
+        const matches = this.info().backend_tools_by_server.filter((item) => item.tool.name === tool &&
+            (server === null ||
+                server === undefined ||
+                (item.server_name ?? item.serverName) === server));
+        if (matches.length === 1) {
+            return matches[0]?.tool.input_schema ?? {};
+        }
+        if (matches.length === 0) {
+            throw new Error(`Backend tool not found: ${tool}`);
+        }
+        throw new Error("Multiple backend tools matched; specify a server");
+    }
+    async invoke(tool, toolInput = {}, options = {}) {
+        const server = options.server ?? this.defaultServer;
+        const wrapper = `${server ? `${server}_` : ""}invoke_tool`;
+        return (await this.invokeWrapper(wrapper, { tool_name: tool, tool_input: toolInput })).text;
+    }
+    close() {
+        this.closed = true;
+        this.session.close();
+    }
+    toExecutableTools() {
+        const result = {};
+        for (const tool of this.tools) {
+            result[tool.name] = {
+                name: tool.name,
+                description: tool.description ?? undefined,
+                inputSchema: tool.inputSchema,
+                execute: async (input = {}) => (await this.invokeWrapper(tool.name, input)).text,
+            };
+        }
+        return result;
+    }
+    writeClient(kind, outputDir, options = {}) {
+        const info = this.info();
+        return generateClientArtifacts(kind, {
+            cliName: options.name ?? this.defaultServer ?? "mcp",
+            bridgeUrl: info.bridge_url,
+            token: info.token,
+            tools: info.backend_tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.input_schema,
+            })),
+            outputDir,
+            sessionPid: 0,
+        });
+    }
+    writeCodeClient(options) {
+        const files = this.writeClient(options.language, options.outputDir, { name: options.name });
+        return {
+            language: options.language,
+            outputDir: options.outputDir,
+            files,
+            environment: options.language === "python" ? { PYTHONPATH: options.outputDir } : {},
+        };
+    }
+}
+export class CompressorClient {
+    options;
+    session = null;
+    mode;
+    authProviders = [];
+    constructor(options) {
+        this.options = options;
+        this.mode = options.mode ?? "compressed";
+    }
+    async connect() {
+        if (this.session) {
+            return new CompressorProxy(this.session, this.defaultServer(), this.authProviders);
+        }
+        const normalized = await normalizeServersWithProviders(this.options.servers);
+        const config = {
+            compressionLevel: this.options.compressionLevel ?? "medium",
+            serverName: this.options.serverName ?? null,
+            includeTools: this.options.includeTools ?? [],
+            excludeTools: this.options.excludeTools ?? [],
+            toonify: this.options.toonify ?? false,
+            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;
+    }
+    defaultServer() {
+        const servers = this.options.servers;
+        if (typeof servers === "string") {
+            return servers.trim().startsWith("{") ? null : "default";
+        }
+        if (isLegacyBackendConfig(servers)) {
+            return "default";
+        }
+        const names = Object.keys(servers);
+        return names.length === 1 ? names[0] : null;
+    }
+}

package/dist/rust_core.d.ts

@@ -0,0 +1,100 @@
+import { type NativeCompressedSession } from "./native.js";
+export interface ToolSpec {
+    name: string;
+    description?: string | null;
+    inputSchema: Record<string, unknown>;
+}
+export declare function compressToolListing(level: string, tools: ToolSpec[]): string;
+export declare function formatToolSchemaResponse(tool: ToolSpec): string;
+export declare function parseToolArgv(tool: ToolSpec, argv: string[]): Record<string, unknown>;
+export type ClientArtifactKind = "cli" | "python" | "typescript";
+export interface ClientGeneratorConfig {
+    cliName: string;
+    bridgeUrl: string;
+    token: string;
+    tools: ToolSpec[];
+    sessionPid: number;
+    outputDir: string;
+}
+export declare function generateClientArtifacts(kind: ClientArtifactKind, config: ClientGeneratorConfig): string[];
+export interface BackendConfig {
+    name: string;
+    commandOrUrl: string;
+    args?: string[];
+}
+export interface CompressedSessionConfig {
+    compressionLevel: string;
+    serverName?: string | null;
+    includeTools?: string[];
+    excludeTools?: string[];
+    toonify?: boolean;
+    transformMode?: string | null;
+}
+export interface JustBashCommandSpec {
+    command_name: string;
+    tool_name?: string;
+    backend_tool_name?: string;
+    backendToolName?: string;
+    description?: string | null;
+    input_schema: Record<string, unknown>;
+    invoke_tool_name: string;
+}
+export interface JustBashProviderSpec {
+    provider_name: string;
+    help_tool_name: string;
+    tools: JustBashCommandSpec[];
+}
+export interface CompressedSessionInfo {
+    bridge_url: string;
+    token: string;
+    frontend_tools: Array<{
+        name: string;
+        description?: string | null;
+        input_schema: Record<string, unknown>;
+    }>;
+    backend_tools: Array<{
+        name: string;
+        description?: string | null;
+        input_schema: Record<string, unknown>;
+    }>;
+    backend_tools_by_server: Array<{
+        server_name?: string;
+        serverName?: string;
+        tool: {
+            name: string;
+            description?: string | null;
+            input_schema: Record<string, unknown>;
+        };
+    }>;
+    just_bash_providers: JustBashProviderSpec[];
+}
+export declare class CompressedSession {
+    private readonly nativeSession;
+    constructor(nativeSession: NativeCompressedSession);
+    info(): CompressedSessionInfo;
+    close(): void;
+    updateAuthProviderHeaders(providerIndex: number, headers: Record<string, string>): void;
+}
+export declare function startCompressedSession(config: CompressedSessionConfig, backends: BackendConfig[]): Promise<CompressedSession>;
+export interface ProviderBackendConfig extends BackendConfig {
+    providerIndex?: number;
+}
+export declare function startCompressedSessionWithAuthProviders(config: CompressedSessionConfig, backends: ProviderBackendConfig[], providers: Array<() => Record<string, string> | Promise<Record<string, string>>>): Promise<CompressedSession>;
+export declare function startCompressedSessionFromMcpConfig(config: CompressedSessionConfig, mcpConfigJson: string): Promise<CompressedSession>;
+export declare function normalizeSdkServers(servers: unknown): BackendConfig[];
+export interface ParsedMcpServer {
+    name: string;
+    command: string;
+    args: string[];
+    env: Array<[string, string]>;
+    cli_prefix: string;
+}
+export declare function parseMcpConfig(configJson: string): ParsedMcpServer[];
+export declare function rememberOAuthBackend(backendUri: string, backendName: string, storeDir: string): void;
+export interface OAuthStoreEntry {
+    backend_name: string;
+    backend_uri: string;
+    store_dir: string;
+}
+export declare function listOAuthCredentials(): OAuthStoreEntry[];
+export declare function clearOAuthCredentials(target?: string | null): string[];

package/dist/rust_core.js

@@ -0,0 +1,103 @@
+import { loadNativeCore } from "./native.js";
+function toNativeTool(tool) {
+    return {
+        name: tool.name,
+        description: tool.description ?? null,
+        input_schema: tool.inputSchema,
+    };
+}
+function stringify(value) {
+    return JSON.stringify(value);
+}
+export function compressToolListing(level, tools) {
+    return loadNativeCore().compressToolListingJson(level, stringify(tools.map(toNativeTool)));
+}
+export function formatToolSchemaResponse(tool) {
+    return loadNativeCore().formatToolSchemaResponseJson(stringify(toNativeTool(tool)));
+}
+export function parseToolArgv(tool, argv) {
+    return JSON.parse(loadNativeCore().parseToolArgvJson(stringify(toNativeTool(tool)), stringify(argv)));
+}
+function toNativeGeneratorConfig(config) {
+    return {
+        cli_name: config.cliName,
+        bridge_url: config.bridgeUrl,
+        token: config.token,
+        tools: config.tools.map(toNativeTool),
+        session_pid: config.sessionPid,
+        output_dir: config.outputDir,
+    };
+}
+export function generateClientArtifacts(kind, config) {
+    return JSON.parse(loadNativeCore().generateClientArtifactsJson(kind, stringify(toNativeGeneratorConfig(config))));
+}
+export class CompressedSession {
+    nativeSession;
+    constructor(nativeSession) {
+        this.nativeSession = nativeSession;
+    }
+    info() {
+        return JSON.parse(this.nativeSession.infoJson());
+    }
+    close() {
+        this.nativeSession.close();
+    }
+    updateAuthProviderHeaders(providerIndex, headers) {
+        this.nativeSession.updateAuthProviderHeadersJson(providerIndex, stringify(headers));
+    }
+}
+function toNativeSessionConfig(config) {
+    return {
+        compression_level: config.compressionLevel,
+        server_name: config.serverName ?? null,
+        include_tools: config.includeTools ?? [],
+        exclude_tools: config.excludeTools ?? [],
+        toonify: config.toonify ?? false,
+        transform_mode: config.transformMode ?? null,
+    };
+}
+function toNativeBackendConfig(backend) {
+    return {
+        name: backend.name,
+        command_or_url: backend.commandOrUrl,
+        args: backend.args ?? [],
+    };
+}
+export async function startCompressedSession(config, backends) {
+    const session = await loadNativeCore().startCompressedSessionJson(stringify(toNativeSessionConfig(config)), stringify(backends.map(toNativeBackendConfig)));
+    return new CompressedSession(session);
+}
+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));
+    return new CompressedSession(session);
+}
+export async function startCompressedSessionFromMcpConfig(config, mcpConfigJson) {
+    const session = await loadNativeCore().startCompressedSessionFromMcpConfigJson(stringify(toNativeSessionConfig(config)), mcpConfigJson);
+    return new CompressedSession(session);
+}
+export function normalizeSdkServers(servers) {
+    const raw = JSON.parse(loadNativeCore().normalizeServersJson(stringify(servers)));
+    return raw.map((backend) => ({
+        name: backend.name,
+        commandOrUrl: backend.command_or_url,
+        args: backend.args ?? [],
+        ...(backend.oauth_app_name == null ? {} : { oauth_app_name: backend.oauth_app_name }),
+    }));
+}
+export function parseMcpConfig(configJson) {
+    return JSON.parse(loadNativeCore().parseMcpConfigJson(configJson));
+}
+export function rememberOAuthBackend(backendUri, backendName, storeDir) {
+    loadNativeCore().rememberOauthBackendJson(backendUri, backendName, storeDir);
+}
+export function listOAuthCredentials() {
+    return JSON.parse(loadNativeCore().listOauthCredentialsJson());
+}
+export function clearOAuthCredentials(target) {
+    return JSON.parse(loadNativeCore().clearOauthCredentialsJson(target ?? null));
+}

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+export type CompressionLevel = "low" | "medium" | "high" | "max";
+export interface StdioBackendConfig {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface HttpBackendConfig {
+    type: "http";
+    url: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+export interface SseBackendConfig {
+    type: "sse";
+    url: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+export type BackendConfig = StdioBackendConfig | HttpBackendConfig | SseBackendConfig;
+export interface JsonConfigServerEntry {
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    /** May be a `URL` object or a string — `normalizeConfigServer` coerces to string. */
+    url?: URL | string;
+    headers?: Record<string, string>;
+    transport?: "sse";
+}
+export interface MCPConfigShape {
+    mcpServers: Record<string, JsonConfigServerEntry>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: `${number}.${number}.${number}`;

package/dist/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+export const VERSION = pkg.version;

package/native/index.d.ts

@@ -0,0 +1,31 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+export declare class NativeCompressedSession {
+  infoJson(): string
+  close(): void
+  updateAuthProviderHeadersJson(providerIndex: number, headersJson: string): void
+}
+
+export declare function clearOauthCredentialsJson(target?: string | undefined | null): string
+
+export declare function compressToolListingJson(level: string, toolsJson: string): string
+
+export declare function formatToolSchemaResponseJson(toolJson: string): string
+
+export declare function generateClientArtifactsJson(kind: string, configJson: string): string
+
+export declare function listOauthCredentialsJson(): string
+
+export declare function normalizeServersJson(serversJson: string): string
+
+export declare function parseMcpConfigJson(configJson: string): string
+
+export declare function parseToolArgvJson(toolJson: string, argvJson: string): string
+
+export declare function rememberOauthBackendJson(backendUri: string, backendName: string, storeDir: string): void
+
+export declare function startCompressedSessionFromMcpConfigJson(configJson: string, mcpConfigJson: string): Promise<NativeCompressedSession>
+
+export declare function startCompressedSessionJson(configJson: string, backendsJson: string): Promise<NativeCompressedSession>
+
+export declare function startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: string): Promise<NativeCompressedSession>