mcpcac 0.0.1

package/dist/auth.d.ts

@@ -0,0 +1,21 @@
+import type { OAuthFlowResult, StartOAuthFlowOptions } from "./types.js";
+/**
+ * Start the OAuth flow for an MCP server.
+ * This is an internal function - consumers should not call this directly.
+ * It is automatically triggered by addMcpCommands when a 401 error occurs.
+ *
+ * This function:
+ * 1. Starts a local callback server on a random port
+ * 2. Initiates OAuth with the MCP server
+ * 3. Opens the browser for user authorization
+ * 4. Waits for the callback with the authorization code
+ * 5. Exchanges the code for tokens
+ * 6. Returns the OAuth state for persistence
+ */
+export declare function startOAuthFlow(options: StartOAuthFlowOptions): Promise<OAuthFlowResult>;
+/**
+ * Check if an error indicates authentication is required.
+ * Internal function used by addMcpCommands.
+ */
+export declare function isAuthRequiredError(err: unknown): boolean;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiB,eAAe,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA0BxF;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC,CA4E7F;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAazD"}

package/dist/auth.js

@@ -0,0 +1,122 @@
+import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
+import { FileOAuthProvider } from "./oauth-provider.js";
+import { startCallbackServer } from "./local-callback-server.js";
+/**
+ * Open a URL in the default browser.
+ * Uses platform-specific commands.
+ */
+async function openBrowser(url) {
+    const { exec } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(exec);
+    const platform = process.platform;
+    const command = (() => {
+        if (platform === "darwin") {
+            return `open "${url}"`;
+        }
+        if (platform === "win32") {
+            return `start "" "${url}"`;
+        }
+        // Linux and others
+        return `xdg-open "${url}"`;
+    })();
+    await execAsync(command);
+}
+/**
+ * Start the OAuth flow for an MCP server.
+ * This is an internal function - consumers should not call this directly.
+ * It is automatically triggered by addMcpCommands when a 401 error occurs.
+ *
+ * This function:
+ * 1. Starts a local callback server on a random port
+ * 2. Initiates OAuth with the MCP server
+ * 3. Opens the browser for user authorization
+ * 4. Waits for the callback with the authorization code
+ * 5. Exchanges the code for tokens
+ * 6. Returns the OAuth state for persistence
+ */
+export async function startOAuthFlow(options) {
+    const { serverUrl, clientName, existingState, onAuthUrl, timeout } = options;
+    // Start local callback server on random port
+    const callbackServer = await startCallbackServer({ timeout });
+    const { redirectUri, waitForCallback, close } = callbackServer;
+    try {
+        // Create OAuth provider with the dynamic redirect URI
+        const oauthProvider = new FileOAuthProvider({
+            serverUrl,
+            redirectUri,
+            clientName,
+            tokens: existingState?.tokens,
+            clientInformation: existingState?.clientInformation,
+            codeVerifier: existingState?.codeVerifier,
+        });
+        // Start the OAuth flow - this will trigger dynamic client registration
+        // and set the authorization URL on the provider
+        const authResult = await auth(oauthProvider, { serverUrl });
+        if (authResult !== "REDIRECT") {
+            // Auth succeeded without redirect (had valid tokens)
+            close();
+            return {
+                success: true,
+                state: oauthProvider.getState(),
+            };
+        }
+        // Get the authorization URL
+        const authUrl = oauthProvider.redirectStartAuthUrl;
+        if (!authUrl) {
+            close();
+            return {
+                success: false,
+                error: "No authorization URL returned from OAuth flow",
+            };
+        }
+        // Open browser or call custom handler
+        const authUrlString = authUrl.toString();
+        if (onAuthUrl) {
+            onAuthUrl(authUrlString);
+        }
+        else {
+            await openBrowser(authUrlString);
+        }
+        // Wait for the callback
+        const callback = await waitForCallback();
+        // Complete the OAuth flow by exchanging the code for tokens
+        const finalResult = await auth(oauthProvider, {
+            serverUrl,
+            authorizationCode: callback.code,
+        });
+        if (finalResult === "REDIRECT") {
+            return {
+                success: false,
+                error: "Unexpected redirect after code exchange",
+            };
+        }
+        return {
+            success: true,
+            state: oauthProvider.getState(),
+        };
+    }
+    catch (err) {
+        close();
+        return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/**
+ * Check if an error indicates authentication is required.
+ * Internal function used by addMcpCommands.
+ */
+export function isAuthRequiredError(err) {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    const message = err.message.toLowerCase();
+    return (message.includes("401") ||
+        message.includes("unauthorized") ||
+        message.includes("authentication required") ||
+        message.includes("not authenticated") ||
+        message.includes("invalid_token") ||
+        message.includes("missing or invalid access token"));
+}

package/dist/index.d.ts

@@ -0,0 +1,120 @@
+/**
+ * # MCP to CLI
+ *
+ * Dynamically generates CLI commands from MCP (Model Context Protocol) server tools.
+ * This module connects to any MCP server, discovers available tools, and creates
+ * corresponding CLI commands with proper argument parsing and validation.
+ *
+ * ## Features
+ *
+ * - **Auto-discovery**: Fetches all tools from the MCP server and creates CLI commands
+ * - **Caching**: Tools are cached for 1 hour to avoid reconnecting on every invocation
+ * - **Session reuse**: MCP session IDs are cached to skip initialization handshake
+ * - **Type-aware parsing**: Handles string, number, boolean, object, and array arguments
+ * - **JSON schema support**: Generates CLI options from tool input schemas
+ * - **OAuth support**: Automatic OAuth authentication on 401 errors (lazy auth)
+ *
+ * ## Example Usage
+ *
+ * ```ts
+ * import { cac } from '@xmorse/cac'
+ * import { addMcpCommands } from 'mcpcac'
+ *
+ * const cli = cac('mycli')
+ *
+ * await addMcpCommands({
+ *   cli,
+ *   commandPrefix: 'mcp',
+ *   clientName: 'my-mcp-client',
+ *   getMcpUrl: () => loadConfig().mcpUrl,
+ *   oauth: {
+ *     clientName: 'My CLI',
+ *     load: () => loadConfig().mcpOauth,
+ *     save: (state) => saveConfig({ mcpOauth: state }),
+ *   },
+ *   loadCache: () => loadConfig().cachedMcpTools,
+ *   saveCache: (cache) => saveConfig({ cachedMcpTools: cache }),
+ * })
+ *
+ * // Login command just saves URL - no auth check, fast!
+ * cli.command('login [url]').action((url) => {
+ *   saveConfig({ mcpUrl: url })
+ *   console.log('URL saved.')
+ * })
+ *
+ * cli.parse()
+ * ```
+ *
+ * @module mcpcac
+ */
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { CAC } from "@xmorse/cac";
+import type { McpOAuthConfig } from "./types.js";
+export type { Transport };
+export type { McpOAuthConfig, McpOAuthState } from "./types.js";
+export interface CachedMcpTools {
+    tools: Array<{
+        name: string;
+        description?: string;
+        inputSchema?: unknown;
+    }>;
+    timestamp: number;
+    sessionId?: string;
+}
+export interface AddMcpCommandsOptions {
+    cli: CAC;
+    commandPrefix: string;
+    /**
+     * Name used when connecting to the MCP server.
+     * @default 'mcp-cli-client'
+     */
+    clientName?: string;
+    /**
+     * Returns the MCP server URL, or undefined if not configured.
+     * Required when using the oauth option.
+     */
+    getMcpUrl?: () => string | undefined;
+    /**
+     * Returns a transport to connect to the MCP server, or null if not configured.
+     * If null is returned, no MCP tool commands will be registered.
+     * @param sessionId - Optional session ID from cache to reuse existing session
+     *
+     * @deprecated Use getMcpUrl + oauth instead for simpler setup
+     */
+    getMcpTransport?: (sessionId?: string) => Transport | null | Promise<Transport | null>;
+    /**
+     * OAuth configuration. When provided, enables automatic OAuth authentication.
+     *
+     * OAuth is lazy - no auth check happens on startup. Authentication is only
+     * triggered when a tool call returns 401. After successful auth, the tool
+     * call is automatically retried.
+     *
+     * The library handles everything internally:
+     * - Detecting 401 errors
+     * - Starting local callback server on random port
+     * - Opening browser for authorization
+     * - Exchanging code for tokens
+     * - Persisting tokens via save()
+     * - Retrying the failed tool call
+     */
+    oauth?: McpOAuthConfig;
+    /**
+     * Load cached MCP tools. Return undefined if no cache exists.
+     */
+    loadCache: () => CachedMcpTools | undefined;
+    /**
+     * Save cached MCP tools. Pass undefined to clear the cache.
+     */
+    saveCache: (cache: CachedMcpTools | undefined) => void;
+}
+/**
+ * Adds MCP tool commands to a cac CLI instance.
+ *
+ * Tools are cached for 1 hour to avoid connecting on every CLI invocation.
+ * Session ID is also cached to skip MCP initialization handshake.
+ *
+ * OAuth is lazy - authentication only happens when a 401 error occurs.
+ * After successful auth, the operation is automatically retried.
+ */
+export declare function addMcpCommands(options: AddMcpCommandsOptions): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAGvC,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,YAAY,CAAC;AAGhE,YAAY,EAAE,SAAS,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC,CAAC;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,GAAG,CAAC;IACT,aAAa,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAErC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAEvF;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;IAEvB;;OAEG;IACH,SAAS,EAAE,MAAM,cAAc,GAAG,SAAS,CAAC;IAE5C;;OAEG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,KAAK,IAAI,CAAC;CACxD;AAkHD;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqMlF"}

package/dist/index.js

@@ -0,0 +1,311 @@
+/**
+ * # MCP to CLI
+ *
+ * Dynamically generates CLI commands from MCP (Model Context Protocol) server tools.
+ * This module connects to any MCP server, discovers available tools, and creates
+ * corresponding CLI commands with proper argument parsing and validation.
+ *
+ * ## Features
+ *
+ * - **Auto-discovery**: Fetches all tools from the MCP server and creates CLI commands
+ * - **Caching**: Tools are cached for 1 hour to avoid reconnecting on every invocation
+ * - **Session reuse**: MCP session IDs are cached to skip initialization handshake
+ * - **Type-aware parsing**: Handles string, number, boolean, object, and array arguments
+ * - **JSON schema support**: Generates CLI options from tool input schemas
+ * - **OAuth support**: Automatic OAuth authentication on 401 errors (lazy auth)
+ *
+ * ## Example Usage
+ *
+ * ```ts
+ * import { cac } from '@xmorse/cac'
+ * import { addMcpCommands } from 'mcpcac'
+ *
+ * const cli = cac('mycli')
+ *
+ * await addMcpCommands({
+ *   cli,
+ *   commandPrefix: 'mcp',
+ *   clientName: 'my-mcp-client',
+ *   getMcpUrl: () => loadConfig().mcpUrl,
+ *   oauth: {
+ *     clientName: 'My CLI',
+ *     load: () => loadConfig().mcpOauth,
+ *     save: (state) => saveConfig({ mcpOauth: state }),
+ *   },
+ *   loadCache: () => loadConfig().cachedMcpTools,
+ *   saveCache: (cache) => saveConfig({ cachedMcpTools: cache }),
+ * })
+ *
+ * // Login command just saves URL - no auth check, fast!
+ * cli.command('login [url]').action((url) => {
+ *   saveConfig({ mcpUrl: url })
+ *   console.log('URL saved.')
+ * })
+ *
+ * cli.parse()
+ * ```
+ *
+ * @module mcpcac
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { FileOAuthProvider } from "./oauth-provider.js";
+import { startOAuthFlow, isAuthRequiredError } from "./auth.js";
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+/**
+ * Convert JSON schema to compact JSON string for display
+ */
+function schemaToString(schema) {
+    const compact = { ...schema };
+    delete compact.description;
+    return JSON.stringify(compact);
+}
+function parseToolArguments(options, inputSchema) {
+    const args = {};
+    if (!inputSchema?.properties) {
+        return args;
+    }
+    for (const [name, schema] of Object.entries(inputSchema.properties)) {
+        let value = options[name];
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value) && value.length === 1) {
+            value = value[0];
+        }
+        const type = schema.type || "string";
+        if ((type === "object" || type === "array") && typeof value === "string") {
+            try {
+                args[name] = JSON.parse(value);
+            }
+            catch {
+                console.error(`Invalid JSON for --${name}: ${value}`);
+                process.exit(1);
+            }
+        }
+        else {
+            args[name] = value;
+        }
+    }
+    return args;
+}
+function outputResult(result) {
+    for (const block of result.content) {
+        if (block.type === "text" && block.text) {
+            console.log(block.text);
+        }
+        else if (block.type === "image") {
+            console.log("[Image content omitted]");
+        }
+        else {
+            console.log(JSON.stringify(block, null, 2));
+        }
+    }
+}
+/**
+ * Create a transport with optional OAuth authentication
+ */
+function createTransportWithAuth(url, sessionId, oauthState, oauth) {
+    let authProvider;
+    if (oauth && oauthState?.tokens) {
+        authProvider = new FileOAuthProvider({
+            serverUrl: url.toString(),
+            redirectUri: "http://localhost/callback", // Placeholder, real one set during auth flow
+            clientName: oauth.clientName,
+            tokens: oauthState.tokens,
+            clientInformation: oauthState.clientInformation,
+            codeVerifier: oauthState.codeVerifier,
+            onStateUpdated: (newState) => {
+                oauth.save(newState);
+            },
+        });
+    }
+    return new StreamableHTTPClientTransport(url, {
+        sessionId,
+        authProvider,
+    });
+}
+/**
+ * Normalize MCP URL for StreamableHTTP transport
+ */
+function normalizeUrl(mcpUrl) {
+    const url = new URL(mcpUrl);
+    if (url.pathname.endsWith("/sse")) {
+        url.pathname = url.pathname.replace(/\/sse$/, "/mcp");
+    }
+    return url;
+}
+/**
+ * Adds MCP tool commands to a cac CLI instance.
+ *
+ * Tools are cached for 1 hour to avoid connecting on every CLI invocation.
+ * Session ID is also cached to skip MCP initialization handshake.
+ *
+ * OAuth is lazy - authentication only happens when a 401 error occurs.
+ * After successful auth, the operation is automatically retried.
+ */
+export async function addMcpCommands(options) {
+    const { cli, commandPrefix, clientName = "mcp-cli-client", getMcpUrl, getMcpTransport, oauth, loadCache, saveCache, } = options;
+    // Helper to get transport - supports both old and new API
+    const getTransport = async (sessionId) => {
+        // New API: getMcpUrl + oauth
+        if (getMcpUrl) {
+            const mcpUrl = getMcpUrl();
+            if (!mcpUrl) {
+                return null;
+            }
+            const url = normalizeUrl(mcpUrl);
+            const oauthState = oauth?.load();
+            return createTransportWithAuth(url, sessionId, oauthState, oauth);
+        }
+        // Legacy API: getMcpTransport
+        if (getMcpTransport) {
+            return getMcpTransport(sessionId);
+        }
+        return null;
+    };
+    // Handle auth required - triggers OAuth flow internally
+    const handleAuthRequired = async (serverUrl) => {
+        if (!oauth) {
+            console.error("Authentication required but OAuth not configured.");
+            console.error("Add oauth config to addMcpCommands() to enable automatic authentication.");
+            return false;
+        }
+        console.log("\n🔐 Authentication required. Opening browser...\n");
+        const result = await startOAuthFlow({
+            serverUrl,
+            clientName: oauth.clientName,
+            existingState: oauth.load(),
+            onAuthUrl: oauth.onAuthUrl,
+        });
+        if (result.success && result.state) {
+            oauth.save(result.state);
+            oauth.onAuthSuccess?.();
+            console.log("✓ Authentication successful! Retrying...\n");
+            return true;
+        }
+        oauth.onAuthError?.(result.error || "Unknown error");
+        console.error(`✗ Authentication failed: ${result.error}\n`);
+        return false;
+    };
+    // Try to use cached tools first (fast path - no network)
+    const cachedTools = loadCache();
+    const isCacheValid = cachedTools && (Date.now() - cachedTools.timestamp) < CACHE_TTL_MS;
+    let tools;
+    let cachedSessionId;
+    if (isCacheValid) {
+        tools = cachedTools.tools;
+        cachedSessionId = cachedTools.sessionId;
+    }
+    else {
+        // Cache invalid/missing - connect to fetch tools
+        const transport = await getTransport();
+        if (!transport) {
+            return;
+        }
+        const client = new Client({ name: clientName, version: "1.0.0" }, { capabilities: {} });
+        try {
+            await client.connect(transport);
+            const result = await client.listTools();
+            tools = result.tools;
+            const sessionId = transport.sessionId;
+            saveCache({
+                tools: tools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    inputSchema: t.inputSchema,
+                })),
+                timestamp: Date.now(),
+                sessionId,
+            });
+            cachedSessionId = sessionId;
+        }
+        catch (err) {
+            // Check if auth is required during tool discovery
+            if (isAuthRequiredError(err) && oauth && getMcpUrl) {
+                const mcpUrl = getMcpUrl();
+                if (mcpUrl) {
+                    const authSuccess = await handleAuthRequired(normalizeUrl(mcpUrl).toString());
+                    if (authSuccess) {
+                        // Retry after auth
+                        return addMcpCommands(options);
+                    }
+                }
+            }
+            console.error(`Failed to connect to MCP server: ${err instanceof Error ? err.message : err}`);
+            return;
+        }
+        finally {
+            await client.close();
+        }
+    }
+    // Register CLI commands for each tool
+    for (const tool of tools) {
+        const inputSchema = tool.inputSchema;
+        const cmdName = `${commandPrefix} ${tool.name}`;
+        const description = tool.description || `Run MCP tool ${tool.name}`;
+        const cmd = cli.command(cmdName, description);
+        if (inputSchema?.properties) {
+            for (const [propName, propSchema] of Object.entries(inputSchema.properties)) {
+                const isRequired = inputSchema.required?.includes(propName) ?? false;
+                const schemaType = propSchema.type || "string";
+                const optionStr = schemaType === "boolean" ? `--${propName}` : `--${propName} <${propName}>`;
+                let optionDesc = propSchema.description || propName;
+                if (isRequired) {
+                    optionDesc += " (required)";
+                }
+                if (schemaType === "object" || schemaType === "array") {
+                    optionDesc += ` (JSON: ${schemaToString(propSchema)})`;
+                }
+                const optionConfig = {};
+                if (propSchema.default !== undefined) {
+                    optionConfig.default = propSchema.default;
+                }
+                if (schemaType === "number" || schemaType === "integer") {
+                    optionConfig.type = [Number];
+                }
+                else if (schemaType !== "boolean") {
+                    optionConfig.type = [String];
+                }
+                cmd.option(optionStr, optionDesc, optionConfig);
+            }
+        }
+        cmd.action(async (cliOptions) => {
+            const parsedArgs = parseToolArguments(cliOptions, inputSchema);
+            const executeWithRetry = async (isRetry = false) => {
+                const transport = await getTransport(isRetry ? undefined : cachedSessionId);
+                if (!transport) {
+                    console.error("MCP transport not available. Run login command first.");
+                    process.exit(1);
+                }
+                const actionClient = new Client({ name: clientName, version: "1.0.0" }, { capabilities: {} });
+                try {
+                    await actionClient.connect(transport);
+                    const result = await actionClient.callTool({ name: tool.name, arguments: parsedArgs });
+                    outputResult(result);
+                }
+                catch (err) {
+                    // On 401, trigger OAuth and retry (only once)
+                    if (!isRetry && isAuthRequiredError(err) && oauth && getMcpUrl) {
+                        const mcpUrl = getMcpUrl();
+                        if (mcpUrl) {
+                            const authSuccess = await handleAuthRequired(normalizeUrl(mcpUrl).toString());
+                            if (authSuccess) {
+                                await actionClient.close();
+                                return executeWithRetry(true);
+                            }
+                        }
+                    }
+                    // Clear cache on error (might be stale)
+                    saveCache(undefined);
+                    console.error(`Error calling ${tool.name}:`, err instanceof Error ? err.message : err);
+                    process.exit(1);
+                }
+                finally {
+                    await actionClient.close();
+                }
+            };
+            await executeWithRetry();
+        });
+    }
+}

package/dist/local-callback-server.d.ts

@@ -0,0 +1,14 @@
+import type { CallbackResult, CallbackServerOptions } from "./types.js";
+/**
+ * Start a local HTTP server to receive OAuth callbacks.
+ * Uses a random available port to avoid conflicts.
+ *
+ * @returns Object with port, redirectUri, waitForCallback promise, and close function
+ */
+export declare function startCallbackServer(options?: CallbackServerOptions): Promise<{
+    port: number;
+    redirectUri: string;
+    waitForCallback: () => Promise<CallbackResult>;
+    close: () => void;
+}>;
+//# sourceMappingURL=local-callback-server.d.ts.map

package/dist/local-callback-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-callback-server.d.ts","sourceRoot":"","sources":["../src/local-callback-server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA2FxE;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;IAC/C,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC,CAgFD"}