From b12683f5422a70015bec9d205ef60290246783a1 Mon Sep 17 00:00:00 2001 From: "Dylan J. Sather" Date: Thu, 27 Mar 2025 20:29:23 -0700 Subject: [PATCH 1/3] MCP --- modelcontextprotocol/.dockerignore | 8 + modelcontextprotocol/.env.example | 12 + modelcontextprotocol/.gitignore | 4 + modelcontextprotocol/CLAUDE.md | 1261 +++++++++++ modelcontextprotocol/Dockerfile | 13 + modelcontextprotocol/README.md | 204 ++ modelcontextprotocol/lib/authProvisions.ts | 46 + modelcontextprotocol/lib/config.ts | 42 + modelcontextprotocol/lib/const.ts | 2 + modelcontextprotocol/lib/pd-client.ts | 42 + .../lib/registerComponentTools.ts | 231 ++ modelcontextprotocol/lib/schemas.ts | 6 + modelcontextprotocol/mcp-inspector.png | Bin 0 -> 368705 bytes modelcontextprotocol/package-lock.json | 1919 +++++++++++++++++ modelcontextprotocol/package.json | 35 + modelcontextprotocol/src/cli.ts | 56 + modelcontextprotocol/src/mcp-server.ts | 23 + modelcontextprotocol/src/sse.ts | 191 ++ modelcontextprotocol/src/stdio.ts | 44 + modelcontextprotocol/tsconfig.json | 16 + pnpm-lock.yaml | 6 +- 21 files changed, 4157 insertions(+), 4 deletions(-) create mode 100644 modelcontextprotocol/.dockerignore create mode 100644 modelcontextprotocol/.env.example create mode 100644 modelcontextprotocol/.gitignore create mode 100644 modelcontextprotocol/CLAUDE.md create mode 100644 modelcontextprotocol/Dockerfile create mode 100644 modelcontextprotocol/README.md create mode 100644 modelcontextprotocol/lib/authProvisions.ts create mode 100644 modelcontextprotocol/lib/config.ts create mode 100644 modelcontextprotocol/lib/const.ts create mode 100644 modelcontextprotocol/lib/pd-client.ts create mode 100644 modelcontextprotocol/lib/registerComponentTools.ts create mode 100644 modelcontextprotocol/lib/schemas.ts create mode 100644 modelcontextprotocol/mcp-inspector.png create mode 100644 modelcontextprotocol/package-lock.json create mode 100644 modelcontextprotocol/package.json create mode 100644 modelcontextprotocol/src/cli.ts create mode 100644 modelcontextprotocol/src/mcp-server.ts create mode 100644 modelcontextprotocol/src/sse.ts create mode 100644 modelcontextprotocol/src/stdio.ts create mode 100644 modelcontextprotocol/tsconfig.json diff --git a/modelcontextprotocol/.dockerignore b/modelcontextprotocol/.dockerignore new file mode 100644 index 0000000000000..840ec9d8e42ea --- /dev/null +++ b/modelcontextprotocol/.dockerignore @@ -0,0 +1,8 @@ +node_modules +dist +*.md +*.png +Dockerfile +*.log +*.env + diff --git a/modelcontextprotocol/.env.example b/modelcontextprotocol/.env.example new file mode 100644 index 0000000000000..75c59a7febc3b --- /dev/null +++ b/modelcontextprotocol/.env.example @@ -0,0 +1,12 @@ +# Pipedream OAuth credentials +PIPEDREAM_CLIENT_ID=your_client_id +PIPEDREAM_CLIENT_SECRET=your_client_secret +PIPEDREAM_PROJECT_ID=your_project_id +PIPEDREAM_PROJECT_ENVIRONMENT=development +PIPEDREAM_WEBHOOK_URI=https://your-webhook.m.pipedream.net + +# Optional: Default app to use (defaults to "slack") +APP=slack + +# Optional: Port for the SSE server (defaults to 3010) +PORT=3010 \ No newline at end of file diff --git a/modelcontextprotocol/.gitignore b/modelcontextprotocol/.gitignore new file mode 100644 index 0000000000000..c09279d6bba05 --- /dev/null +++ b/modelcontextprotocol/.gitignore @@ -0,0 +1,4 @@ +node_modules +.env* +!.env.example +dist diff --git a/modelcontextprotocol/CLAUDE.md b/modelcontextprotocol/CLAUDE.md new file mode 100644 index 0000000000000..7c0438169a525 --- /dev/null +++ b/modelcontextprotocol/CLAUDE.md @@ -0,0 +1,1261 @@ +# MCP docs + +Consider these docs your constitution. They outline relevant details of the MCP spec that will be helpful for developing MCP servers. + +## Dev / build + +See package.json scripts. + +## MCP spec schema.ts + +/* JSON-RPC types */ + +/** + * Refers to any valid JSON-RPC object that can be decoded off the wire, or encoded to be sent. + */ +export type JSONRPCMessage = + | JSONRPCRequest + | JSONRPCNotification + | JSONRPCBatchRequest + | JSONRPCResponse + | JSONRPCError + | JSONRPCBatchResponse; + +/** + * A JSON-RPC batch request, as described in https://www.jsonrpc.org/specification#batch. + */ +export type JSONRPCBatchRequest = (JSONRPCRequest | JSONRPCNotification)[]; + +/** + * A JSON-RPC batch response, as described in https://www.jsonrpc.org/specification#batch. + */ +export type JSONRPCBatchResponse = (JSONRPCResponse | JSONRPCError)[]; + +export const LATEST_PROTOCOL_VERSION = "2025-03-26"; +export const JSONRPC_VERSION = "2.0"; + +/** + * A progress token, used to associate progress notifications with the original request. + */ +export type ProgressToken = string | number; + +/** + * An opaque token used to represent a cursor for pagination. + */ +export type Cursor = string; + +export interface Request { + method: string; + params?: { + _meta?: { + /** + * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications. + */ + progressToken?: ProgressToken; + }; + [key: string]: unknown; + }; +} + +export interface Notification { + method: string; + params?: { + /** + * This parameter name is reserved by MCP to allow clients and servers to attach additional metadata to their notifications. + */ + _meta?: { [key: string]: unknown }; + [key: string]: unknown; + }; +} + +export interface Result { + /** + * This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses. + */ + _meta?: { [key: string]: unknown }; + [key: string]: unknown; +} + +/** + * A uniquely identifying ID for a request in JSON-RPC. + */ +export type RequestId = string | number; + +/** + * A request that expects a response. + */ +export interface JSONRPCRequest extends Request { + jsonrpc: typeof JSONRPC_VERSION; + id: RequestId; +} + +/** + * A notification which does not expect a response. + */ +export interface JSONRPCNotification extends Notification { + jsonrpc: typeof JSONRPC_VERSION; +} + +/** + * A successful (non-error) response to a request. + */ +export interface JSONRPCResponse { + jsonrpc: typeof JSONRPC_VERSION; + id: RequestId; + result: Result; +} + +// Standard JSON-RPC error codes +export const PARSE_ERROR = -32700; +export const INVALID_REQUEST = -32600; +export const METHOD_NOT_FOUND = -32601; +export const INVALID_PARAMS = -32602; +export const INTERNAL_ERROR = -32603; + +/** + * A response to a request that indicates an error occurred. + */ +export interface JSONRPCError { + jsonrpc: typeof JSONRPC_VERSION; + id: RequestId; + error: { + /** + * The error type that occurred. + */ + code: number; + /** + * A short description of the error. The message SHOULD be limited to a concise single sentence. + */ + message: string; + /** + * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.). + */ + data?: unknown; + }; +} + +/* Empty result */ +/** + * A response that indicates success but carries no data. + */ +export type EmptyResult = Result; + +/* Cancellation */ +/** + * This notification can be sent by either side to indicate that it is cancelling a previously-issued request. + * + * The request SHOULD still be in-flight, but due to communication latency, it is always possible that this notification MAY arrive after the request has already finished. + * + * This notification indicates that the result will be unused, so any associated processing SHOULD cease. + * + * A client MUST NOT attempt to cancel its `initialize` request. + */ +export interface CancelledNotification extends Notification { + method: "notifications/cancelled"; + params: { + /** + * The ID of the request to cancel. + * + * This MUST correspond to the ID of a request previously issued in the same direction. + */ + requestId: RequestId; + + /** + * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user. + */ + reason?: string; + }; +} + +/* Initialization */ +/** + * This request is sent from the client to the server when it first connects, asking it to begin initialization. + */ +export interface InitializeRequest extends Request { + method: "initialize"; + params: { + /** + * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well. + */ + protocolVersion: string; + capabilities: ClientCapabilities; + clientInfo: Implementation; + }; +} + +/** + * After receiving an initialize request from the client, the server sends this response. + */ +export interface InitializeResult extends Result { + /** + * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect. + */ + protocolVersion: string; + capabilities: ServerCapabilities; + serverInfo: Implementation; + + /** + * Instructions describing how to use the server and its features. + * + * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt. + */ + instructions?: string; +} + +/** + * This notification is sent from the client to the server after initialization has finished. + */ +export interface InitializedNotification extends Notification { + method: "notifications/initialized"; +} + +/** + * Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities. + */ +export interface ClientCapabilities { + /** + * Experimental, non-standard capabilities that the client supports. + */ + experimental?: { [key: string]: object }; + /** + * Present if the client supports listing roots. + */ + roots?: { + /** + * Whether the client supports notifications for changes to the roots list. + */ + listChanged?: boolean; + }; + /** + * Present if the client supports sampling from an LLM. + */ + sampling?: object; +} + +/** + * Capabilities that a server may support. Known capabilities are defined here, in this schema, but this is not a closed set: any server can define its own, additional capabilities. + */ +export interface ServerCapabilities { + /** + * Experimental, non-standard capabilities that the server supports. + */ + experimental?: { [key: string]: object }; + /** + * Present if the server supports sending log messages to the client. + */ + logging?: object; + /** + * Present if the server supports argument autocompletion suggestions. + */ + completions?: object; + /** + * Present if the server offers any prompt templates. + */ + prompts?: { + /** + * Whether this server supports notifications for changes to the prompt list. + */ + listChanged?: boolean; + }; + /** + * Present if the server offers any resources to read. + */ + resources?: { + /** + * Whether this server supports subscribing to resource updates. + */ + subscribe?: boolean; + /** + * Whether this server supports notifications for changes to the resource list. + */ + listChanged?: boolean; + }; + /** + * Present if the server offers any tools to call. + */ + tools?: { + /** + * Whether this server supports notifications for changes to the tool list. + */ + listChanged?: boolean; + }; +} + +/** + * Describes the name and version of an MCP implementation. + */ +export interface Implementation { + name: string; + version: string; +} + +/* Ping */ +/** + * A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected. + */ +export interface PingRequest extends Request { + method: "ping"; +} + +/* Progress notifications */ +/** + * An out-of-band notification used to inform the receiver of a progress update for a long-running request. + */ +export interface ProgressNotification extends Notification { + method: "notifications/progress"; + params: { + /** + * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding. + */ + progressToken: ProgressToken; + /** + * The progress thus far. This should increase every time progress is made, even if the total is unknown. + * + * @TJS-type number + */ + progress: number; + /** + * Total number of items to process (or total progress required), if known. + * + * @TJS-type number + */ + total?: number; + /** + * An optional message describing the current progress. + */ + message?: string; + }; +} + +/* Pagination */ +export interface PaginatedRequest extends Request { + params?: { + /** + * An opaque token representing the current pagination position. + * If provided, the server should return results starting after this cursor. + */ + cursor?: Cursor; + }; +} + +export interface PaginatedResult extends Result { + /** + * An opaque token representing the pagination position after the last returned result. + * If present, there may be more results available. + */ + nextCursor?: Cursor; +} + +/* Resources */ +/** + * Sent from the client to request a list of resources the server has. + */ +export interface ListResourcesRequest extends PaginatedRequest { + method: "resources/list"; +} + +/** + * The server's response to a resources/list request from the client. + */ +export interface ListResourcesResult extends PaginatedResult { + resources: Resource[]; +} + +/** + * Sent from the client to request a list of resource templates the server has. + */ +export interface ListResourceTemplatesRequest extends PaginatedRequest { + method: "resources/templates/list"; +} + +/** + * The server's response to a resources/templates/list request from the client. + */ +export interface ListResourceTemplatesResult extends PaginatedResult { + resourceTemplates: ResourceTemplate[]; +} + +/** + * Sent from the client to the server, to read a specific resource URI. + */ +export interface ReadResourceRequest extends Request { + method: "resources/read"; + params: { + /** + * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it. + * + * @format uri + */ + uri: string; + }; +} + +/** + * The server's response to a resources/read request from the client. + */ +export interface ReadResourceResult extends Result { + contents: (TextResourceContents | BlobResourceContents)[]; +} + +/** + * An optional notification from the server to the client, informing it that the list of resources it can read from has changed. This may be issued by servers without any previous subscription from the client. + */ +export interface ResourceListChangedNotification extends Notification { + method: "notifications/resources/list_changed"; +} + +/** + * Sent from the client to request resources/updated notifications from the server whenever a particular resource changes. + */ +export interface SubscribeRequest extends Request { + method: "resources/subscribe"; + params: { + /** + * The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it. + * + * @format uri + */ + uri: string; + }; +} + +/** + * Sent from the client to request cancellation of resources/updated notifications from the server. This should follow a previous resources/subscribe request. + */ +export interface UnsubscribeRequest extends Request { + method: "resources/unsubscribe"; + params: { + /** + * The URI of the resource to unsubscribe from. + * + * @format uri + */ + uri: string; + }; +} + +/** + * A notification from the server to the client, informing it that a resource has changed and may need to be read again. This should only be sent if the client previously sent a resources/subscribe request. + */ +export interface ResourceUpdatedNotification extends Notification { + method: "notifications/resources/updated"; + params: { + /** + * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to. + * + * @format uri + */ + uri: string; + }; +} + +/** + * A known resource that the server is capable of reading. + */ +export interface Resource { + /** + * The URI of this resource. + * + * @format uri + */ + uri: string; + + /** + * A human-readable name for this resource. + * + * This can be used by clients to populate UI elements. + */ + name: string; + + /** + * A description of what this resource represents. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description?: string; + + /** + * The MIME type of this resource, if known. + */ + mimeType?: string; + + /** + * Optional annotations for the client. + */ + annotations?: Annotations; +} + +/** + * A template description for resources available on the server. + */ +export interface ResourceTemplate { + /** + * A URI template (according to RFC 6570) that can be used to construct resource URIs. + * + * @format uri-template + */ + uriTemplate: string; + + /** + * A human-readable name for the type of resource this template refers to. + * + * This can be used by clients to populate UI elements. + */ + name: string; + + /** + * A description of what this template is for. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description?: string; + + /** + * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type. + */ + mimeType?: string; + + /** + * Optional annotations for the client. + */ + annotations?: Annotations; +} + +/** + * The contents of a specific resource or sub-resource. + */ +export interface ResourceContents { + /** + * The URI of this resource. + * + * @format uri + */ + uri: string; + /** + * The MIME type of this resource, if known. + */ + mimeType?: string; +} + +export interface TextResourceContents extends ResourceContents { + /** + * The text of the item. This must only be set if the item can actually be represented as text (not binary data). + */ + text: string; +} + +export interface BlobResourceContents extends ResourceContents { + /** + * A base64-encoded string representing the binary data of the item. + * + * @format byte + */ + blob: string; +} + +/* Prompts */ +/** + * Sent from the client to request a list of prompts and prompt templates the server has. + */ +export interface ListPromptsRequest extends PaginatedRequest { + method: "prompts/list"; +} + +/** + * The server's response to a prompts/list request from the client. + */ +export interface ListPromptsResult extends PaginatedResult { + prompts: Prompt[]; +} + +/** + * Used by the client to get a prompt provided by the server. + */ +export interface GetPromptRequest extends Request { + method: "prompts/get"; + params: { + /** + * The name of the prompt or prompt template. + */ + name: string; + /** + * Arguments to use for templating the prompt. + */ + arguments?: { [key: string]: string }; + }; +} + +/** + * The server's response to a prompts/get request from the client. + */ +export interface GetPromptResult extends Result { + /** + * An optional description for the prompt. + */ + description?: string; + messages: PromptMessage[]; +} + +/** + * A prompt or prompt template that the server offers. + */ +export interface Prompt { + /** + * The name of the prompt or prompt template. + */ + name: string; + /** + * An optional description of what this prompt provides + */ + description?: string; + /** + * A list of arguments to use for templating the prompt. + */ + arguments?: PromptArgument[]; +} + +/** + * Describes an argument that a prompt can accept. + */ +export interface PromptArgument { + /** + * The name of the argument. + */ + name: string; + /** + * A human-readable description of the argument. + */ + description?: string; + /** + * Whether this argument must be provided. + */ + required?: boolean; +} + +/** + * The sender or recipient of messages and data in a conversation. + */ +export type Role = "user" | "assistant"; + +/** + * Describes a message returned as part of a prompt. + * + * This is similar to `SamplingMessage`, but also supports the embedding of + * resources from the MCP server. + */ +export interface PromptMessage { + role: Role; + content: TextContent | ImageContent | AudioContent | EmbeddedResource; +} + +/** + * The contents of a resource, embedded into a prompt or tool call result. + * + * It is up to the client how best to render embedded resources for the benefit + * of the LLM and/or the user. + */ +export interface EmbeddedResource { + type: "resource"; + resource: TextResourceContents | BlobResourceContents; + + /** + * Optional annotations for the client. + */ + annotations?: Annotations; +} + +/** + * An optional notification from the server to the client, informing it that the list of prompts it offers has changed. This may be issued by servers without any previous subscription from the client. + */ +export interface PromptListChangedNotification extends Notification { + method: "notifications/prompts/list_changed"; +} + +/* Tools */ +/** + * Sent from the client to request a list of tools the server has. + */ +export interface ListToolsRequest extends PaginatedRequest { + method: "tools/list"; +} + +/** + * The server's response to a tools/list request from the client. + */ +export interface ListToolsResult extends PaginatedResult { + tools: Tool[]; +} + +/** + * The server's response to a tool call. + * + * Any errors that originate from the tool SHOULD be reported inside the result + * object, with `isError` set to true, _not_ as an MCP protocol-level error + * response. Otherwise, the LLM would not be able to see that an error occurred + * and self-correct. + * + * However, any errors in _finding_ the tool, an error indicating that the + * server does not support tool calls, or any other exceptional conditions, + * should be reported as an MCP error response. + */ +export interface CallToolResult extends Result { + content: (TextContent | ImageContent | AudioContent | EmbeddedResource)[]; + + /** + * Whether the tool call ended in an error. + * + * If not set, this is assumed to be false (the call was successful). + */ + isError?: boolean; +} + +/** + * Used by the client to invoke a tool provided by the server. + */ +export interface CallToolRequest extends Request { + method: "tools/call"; + params: { + name: string; + arguments?: { [key: string]: unknown }; + }; +} + +/** + * An optional notification from the server to the client, informing it that the list of tools it offers has changed. This may be issued by servers without any previous subscription from the client. + */ +export interface ToolListChangedNotification extends Notification { + method: "notifications/tools/list_changed"; +} + +/** + * Additional properties describing a Tool to clients. + * + * NOTE: all properties in ToolAnnotations are **hints**. + * They are not guaranteed to provide a faithful description of + * tool behavior (including descriptive properties like `title`). + * + * Clients should never make tool use decisions based on ToolAnnotations + * received from untrusted servers. + */ +export interface ToolAnnotations { + /** + * A human-readable title for the tool. + */ + title?: string; + + /** + * If true, the tool does not modify its environment. + * + * Default: false + */ + readOnlyHint?: boolean; + + /** + * If true, the tool may perform destructive updates to its environment. + * If false, the tool performs only additive updates. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: true + */ + destructiveHint?: boolean; + + /** + * If true, calling the tool repeatedly with the same arguments + * will have no additional effect on the its environment. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: false + */ + idempotentHint?: boolean; + + /** + * If true, this tool may interact with an "open world" of external + * entities. If false, the tool's domain of interaction is closed. + * For example, the world of a web search tool is open, whereas that + * of a memory tool is not. + * + * Default: true + */ + openWorldHint?: boolean; +} + +/** + * Definition for a tool the client can call. + */ +export interface Tool { + /** + * The name of the tool. + */ + name: string; + + /** + * A human-readable description of the tool. + * + * This can be used by clients to improve the LLM's understanding of available tools. It can be thought of like a "hint" to the model. + */ + description?: string; + + /** + * A JSON Schema object defining the expected parameters for the tool. + */ + inputSchema: { + type: "object"; + properties?: { [key: string]: object }; + required?: string[]; + }; + + /** + * Optional additional tool information. + */ + annotations?: ToolAnnotations; +} + +/* Logging */ +/** + * A request from the client to the server, to enable or adjust logging. + */ +export interface SetLevelRequest extends Request { + method: "logging/setLevel"; + params: { + /** + * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/message. + */ + level: LoggingLevel; + }; +} + +/** + * Notification of a log message passed from server to client. If no logging/setLevel request has been sent from the client, the server MAY decide which messages to send automatically. + */ +export interface LoggingMessageNotification extends Notification { + method: "notifications/message"; + params: { + /** + * The severity of this log message. + */ + level: LoggingLevel; + /** + * An optional name of the logger issuing this message. + */ + logger?: string; + /** + * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here. + */ + data: unknown; + }; +} + +/** + * The severity of a log message. + * + * These map to syslog message severities, as specified in RFC-5424: + * https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1 + */ +export type LoggingLevel = + | "debug" + | "info" + | "notice" + | "warning" + | "error" + | "critical" + | "alert" + | "emergency"; + +/* Sampling */ +/** + * A request from the server to sample an LLM via the client. The client has full discretion over which model to select. The client should also inform the user before beginning sampling, to allow them to inspect the request (human in the loop) and decide whether to approve it. + */ +export interface CreateMessageRequest extends Request { + method: "sampling/createMessage"; + params: { + messages: SamplingMessage[]; + /** + * The server's preferences for which model to select. The client MAY ignore these preferences. + */ + modelPreferences?: ModelPreferences; + /** + * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt. + */ + systemPrompt?: string; + /** + * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request. + */ + includeContext?: "none" | "thisServer" | "allServers"; + /** + * @TJS-type number + */ + temperature?: number; + /** + * The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested. + */ + maxTokens: number; + stopSequences?: string[]; + /** + * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific. + */ + metadata?: object; + }; +} + +/** + * The client's response to a sampling/create_message request from the server. The client should inform the user before returning the sampled message, to allow them to inspect the response (human in the loop) and decide whether to allow the server to see it. + */ +export interface CreateMessageResult extends Result, SamplingMessage { + /** + * The name of the model that generated the message. + */ + model: string; + /** + * The reason why sampling stopped, if known. + */ + stopReason?: "endTurn" | "stopSequence" | "maxTokens" | string; +} + +/** + * Describes a message issued to or received from an LLM API. + */ +export interface SamplingMessage { + role: Role; + content: TextContent | ImageContent | AudioContent; +} + +/** + * Optional annotations for the client. The client can use annotations to inform how objects are used or displayed + */ +export interface Annotations { + /** + * Describes who the intended customer of this object or data is. + * + * It can include multiple entries to indicate content useful for multiple audiences (e.g., `["user", "assistant"]`). + */ + audience?: Role[]; + + /** + * Describes how important this data is for operating the server. + * + * A value of 1 means "most important," and indicates that the data is + * effectively required, while 0 means "least important," and indicates that + * the data is entirely optional. + * + * @TJS-type number + * @minimum 0 + * @maximum 1 + */ + priority?: number; +} + +/** + * Text provided to or from an LLM. + */ +export interface TextContent { + type: "text"; + + /** + * The text content of the message. + */ + text: string; + + /** + * Optional annotations for the client. + */ + annotations?: Annotations; +} + +/** + * An image provided to or from an LLM. + */ +export interface ImageContent { + type: "image"; + + /** + * The base64-encoded image data. + * + * @format byte + */ + data: string; + + /** + * The MIME type of the image. Different providers may support different image types. + */ + mimeType: string; + + /** + * Optional annotations for the client. + */ + annotations?: Annotations; +} + +/** + * Audio provided to or from an LLM. + */ +export interface AudioContent { + type: "audio"; + + /** + * The base64-encoded audio data. + * + * @format byte + */ + data: string; + + /** + * The MIME type of the audio. Different providers may support different audio types. + */ + mimeType: string; + + /** + * Optional annotations for the client. + */ + annotations?: Annotations; +} + +/** + * The server's preferences for model selection, requested of the client during sampling. + * + * Because LLMs can vary along multiple dimensions, choosing the "best" model is + * rarely straightforward. Different models excel in different areas—some are + * faster but less capable, others are more capable but more expensive, and so + * on. This interface allows servers to express their priorities across multiple + * dimensions to help clients make an appropriate selection for their use case. + * + * These preferences are always advisory. The client MAY ignore them. It is also + * up to the client to decide how to interpret these preferences and how to + * balance them against other considerations. + */ +export interface ModelPreferences { + /** + * Optional hints to use for model selection. + * + * If multiple hints are specified, the client MUST evaluate them in order + * (such that the first match is taken). + * + * The client SHOULD prioritize these hints over the numeric priorities, but + * MAY still use the priorities to select from ambiguous matches. + */ + hints?: ModelHint[]; + + /** + * How much to prioritize cost when selecting a model. A value of 0 means cost + * is not important, while a value of 1 means cost is the most important + * factor. + * + * @TJS-type number + * @minimum 0 + * @maximum 1 + */ + costPriority?: number; + + /** + * How much to prioritize sampling speed (latency) when selecting a model. A + * value of 0 means speed is not important, while a value of 1 means speed is + * the most important factor. + * + * @TJS-type number + * @minimum 0 + * @maximum 1 + */ + speedPriority?: number; + + /** + * How much to prioritize intelligence and capabilities when selecting a + * model. A value of 0 means intelligence is not important, while a value of 1 + * means intelligence is the most important factor. + * + * @TJS-type number + * @minimum 0 + * @maximum 1 + */ + intelligencePriority?: number; +} + +/** + * Hints to use for model selection. + * + * Keys not declared here are currently left unspecified by the spec and are up + * to the client to interpret. + */ +export interface ModelHint { + /** + * A hint for a model name. + * + * The client SHOULD treat this as a substring of a model name; for example: + * - `claude-3-5-sonnet` should match `claude-3-5-sonnet-20241022` + * - `sonnet` should match `claude-3-5-sonnet-20241022`, `claude-3-sonnet-20240229`, etc. + * - `claude` should match any Claude model + * + * The client MAY also map the string to a different provider's model name or a different model family, as long as it fills a similar niche; for example: + * - `gemini-1.5-flash` could match `claude-3-haiku-20240307` + */ + name?: string; +} + +/* Autocomplete */ +/** + * A request from the client to the server, to ask for completion options. + */ +export interface CompleteRequest extends Request { + method: "completion/complete"; + params: { + ref: PromptReference | ResourceReference; + /** + * The argument's information + */ + argument: { + /** + * The name of the argument + */ + name: string; + /** + * The value of the argument to use for completion matching. + */ + value: string; + }; + }; +} + +/** + * The server's response to a completion/complete request + */ +export interface CompleteResult extends Result { + completion: { + /** + * An array of completion values. Must not exceed 100 items. + */ + values: string[]; + /** + * The total number of completion options available. This can exceed the number of values actually sent in the response. + */ + total?: number; + /** + * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown. + */ + hasMore?: boolean; + }; +} + +/** + * A reference to a resource or resource template definition. + */ +export interface ResourceReference { + type: "ref/resource"; + /** + * The URI or URI template of the resource. + * + * @format uri-template + */ + uri: string; +} + +/** + * Identifies a prompt. + */ +export interface PromptReference { + type: "ref/prompt"; + /** + * The name of the prompt or prompt template + */ + name: string; +} + +/* Roots */ +/** + * Sent from the server to request a list of root URIs from the client. Roots allow + * servers to ask for specific directories or files to operate on. A common example + * for roots is providing a set of repositories or directories a server should operate + * on. + * + * This request is typically used when the server needs to understand the file system + * structure or access specific locations that the client has permission to read from. + */ +export interface ListRootsRequest extends Request { + method: "roots/list"; +} + +/** + * The client's response to a roots/list request from the server. + * This result contains an array of Root objects, each representing a root directory + * or file that the server can operate on. + */ +export interface ListRootsResult extends Result { + roots: Root[]; +} + +/** + * Represents a root directory or file that the server can operate on. + */ +export interface Root { + /** + * The URI identifying the root. This *must* start with file:// for now. + * This restriction may be relaxed in future versions of the protocol to allow + * other URI schemes. + * + * @format uri + */ + uri: string; + /** + * An optional name for the root. This can be used to provide a human-readable + * identifier for the root, which may be useful for display purposes or for + * referencing the root in other parts of the application. + */ + name?: string; +} + +/** + * A notification from the client to the server, informing it that the list of roots has changed. + * This notification should be sent whenever the client adds, removes, or modifies any root. + * The server should then request an updated list of roots using the ListRootsRequest. + */ +export interface RootsListChangedNotification extends Notification { + method: "notifications/roots/list_changed"; +} + +/* Client messages */ +export type ClientRequest = + | PingRequest + | InitializeRequest + | CompleteRequest + | SetLevelRequest + | GetPromptRequest + | ListPromptsRequest + | ListResourcesRequest + | ReadResourceRequest + | SubscribeRequest + | UnsubscribeRequest + | CallToolRequest + | ListToolsRequest; + +export type ClientNotification = + | CancelledNotification + | ProgressNotification + | InitializedNotification + | RootsListChangedNotification; + +export type ClientResult = EmptyResult | CreateMessageResult | ListRootsResult; + +/* Server messages */ +export type ServerRequest = + | PingRequest + | CreateMessageRequest + | ListRootsRequest; + +export type ServerNotification = + | CancelledNotification + | ProgressNotification + | LoggingMessageNotification + | ResourceUpdatedNotification + | ResourceListChangedNotification + | ToolListChangedNotification + | PromptListChangedNotification; + +export type ServerResult = + | EmptyResult + | InitializeResult + | CompleteResult + | GetPromptResult + | ListPromptsResult + | ListResourcesResult + | ReadResourceResult + | CallToolResult + | ListToolsResult; diff --git a/modelcontextprotocol/Dockerfile b/modelcontextprotocol/Dockerfile new file mode 100644 index 0000000000000..d85a4d9820ba6 --- /dev/null +++ b/modelcontextprotocol/Dockerfile @@ -0,0 +1,13 @@ +FROM node:22.14.0-alpine3.21 + +WORKDIR /app +COPY . . + +# Install dependencies and build +RUN npm ci && npm run build + +ENV PORT=3010 +EXPOSE 3010 + +# Command to run the SSE server +CMD ["npm", "run", "start:sse:prod"] diff --git a/modelcontextprotocol/README.md b/modelcontextprotocol/README.md new file mode 100644 index 0000000000000..c573c672548ee --- /dev/null +++ b/modelcontextprotocol/README.md @@ -0,0 +1,204 @@ +# Pipedream MCP server + +Run **your own MCP server** for [over 2,500 apps and APIs](https://pipedream.com/apps). + +You can: + +- [Run the servers locally](#running-the-server-via-npx) with `npx @pipedream/mcp` +- [Host the servers yourself](#hosting-your-own-server) to use them within your app or company + +## ⭐ Features + +- Run your own MCP server for over 2,500 apps +- Manage servers **for your users**, in your own app. +- Connect accounts, configure params, and make API requests, all via tools +- Fully-managed OAuth and credential storage ([see security docs](https://pipedream.com/docs/privacy-and-security/#third-party-oauth-grants-api-keys-and-environment-variables)) + +## 🚀 Getting Started + +Pipedream's MCP servers use the [Pipedream Connect API](https://pipedream.com/docs/connect/) to manage auth and make API requests. To run an MCP server, you'll need a Pipedream project and Pipedream API credentials. + +1. [Sign up for Pipedream](https://pipedream.com/auth/signup) +2. [Create a project](https://pipedream.com/docs/workflows/projects/#creating-projects). Any accounts connected via MCP will be stored here. +3. [Create a Pipedream OAuth client](https://pipedream.com/docs/rest-api/auth/#creating-an-oauth-client) +4. Set the following environment variables using your preferred method (directly in your shell session, dot files, etc.) + +```bash +PIPEDREAM_CLIENT_ID=your_client_id +PIPEDREAM_CLIENT_SECRET=your_client_secret +PIPEDREAM_PROJECT_ID=your_project_id +PIPEDREAM_PROJECT_ENVIRONMENT=development +``` + +### Pipedream concepts to understand + +If you're running MCP servers for your app, you'll likely want to use the [SSE interface](#sse). The SSE server accepts two route params: + +1. `external_user_id` — This is your user’s ID, in your system — whatever you use to uniquely identify them. Any requests made to that route are coupled to that end user, and would use the auth Pipedream stores for that user. [See the docs](https://pipedream.com/docs/connect/api/#external-users) for more detail. +2. `app` — The app's "name slug" (the unique identifier for the app), found in the **Authentication** section of [any Pipedream app](https://pipedream.com/apps). For example, the app slug for [Slack](https://pipedream.com/apps/slack) is `slack`. + +If your user `123` wants to connect to the `slack` MCP server, your MCP client would make a request to the `/123/slack` route. [See the SSE docs below](#sse) for more detail. + +### Running the server via `npx` + +Pipedream MCP servers provide [two interfaces](https://modelcontextprotocol.io/docs/concepts/architecture#transport-layer) clients can connect to: + +1. **Stdio**: Uses standard input / output. Ideal if you want to connect accounts and make MCP requests from editors and other local MCP clients. Great for testing. +2. **SSE**: Uses [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events) to communicate with clients. Use this when you want to host an internet-facing MCP server that other services / your customers can use. + +#### Stdio + +First, [set these variables in your environment](#getting-started). + +Run the stdio server for a specific app, passing the app's name slug to the `--app` option: + +```bash +npx @pipedream/mcp stdio --app slack +``` + +You can also specify an optional [external user ID](#pipedream-concepts-to-understand) — whatever ID you use to identify your user in your app (otherwise a random UUID will be generated): + +```bash +npx @pipedream/mcp stdio --app slack --external-user-id user123 +``` + +#### SSE + +First, [set these variables in your environment](#getting-started). + +Run the SSE server: + +```bash +npx @pipedream/mcp sse +``` + +This exposes a generic MCP server that allows you to connect to any of our 2,500+ apps by passing [the app's name slug](#pipedream-concepts-to-understand) **directly in the route**: + +```console +❯ npx @pipedream/mcp sse +Server is running on port 3010 +Routes configured: +- GET / - Health check +- GET /:external_user_id/:app - App-specific SSE connection endpoint +- POST /:external_user_id/:app/messages - App-specific message handler +``` + +To connect to the server: + +1. Connect to `http://localhost:3010/:external_user_id/:app` where: + + - `:external_user_id` is a unique identifier for the session + - `:app` is the Pipedream app to use (e.g., "slack") + +2. The server will establish an SSE connection and register tools for the specified app. + +3. To send messages, post to `http://localhost:3010/:external_user_id/:app/messages?sessionId=` where: + - `` is provided in the response from the initial connection + +You can also specify an app and port via CLI: + +```bash +npx @pipedream/mcp sse --app slack --port 8080 +``` + +```console +❯ npx @pipedream/mcp sse --app slack --port 8080 +Server is running on port 8080 +Routes configured: +- GET / - Health check +- GET /:external_user_id/slack - App-specific SSE connection endpoint +- POST /:external_user_id/slack/messages - App-specific message handler +``` + +## Hosting your own server + +### Using the `Dockerfile` + +If you have Docker installed locally, you can build and run the container: + +```console +> docker build -t pipedream-connect . +> docker run -d --name pd-mcp -p 3010:3010 --env-file .env pipedream-connect:latest +``` + +This exposes a generic MCP server at [http://localhost:3010/:external_user_id/:app](http://localhost:3010/:external_user_id/:app). + +### Step-by-step + +The SSE server runs as a Node.js Express app. The implementation is simple and meant to be a reference. You should [add authorization](#authorization) and [customize the app you need](#customization). + +Clone the repo and install dependencies: + +```bash +npm install +``` + +[Set these variables in your environment](#getting-started) in using whatever env / secrets store you use in your infra. To test this locally, copy the `.env.example` file: + +```bash +cp .env.example .env +``` + +and fill in the values: + +```bash +# Pipedream OAuth credentials +PIPEDREAM_CLIENT_ID=your_client_id +PIPEDREAM_CLIENT_SECRET=your_client_secret + +# From the project settings +PIPEDREAM_PROJECT_ID=your_project_id +PIPEDREAM_PROJECT_ENVIRONMENT=development + +# Pipedream can send you webhook notifications on account connection, account failure, etc. +PIPEDREAM_WEBHOOK_URI=https://your-webhook.m.pipedream.net + +# Optional: Default app to use (defaults to "slack") +APP=slack + +# Optional: Port for the SSE server (defaults to 3010) +PORT=3010 +``` + +Run the build: + +```bash +npm run build +``` + +And run the SSE server: + +```bash +npm run start:sse:prod +``` + +## Authorization + +MCP recently added support for [servers authorizing requests using OAuth](https://spec.modelcontextprotocol.io/specification/2025-03-26/basic/authorization/). When you host your own server, you should implement OAuth support to protect access to customer data. + +## Debugging + +First, [set these variables in your environment](#getting-started). + +Use [the MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) or your preferred MCP client to connect to the server: + +```bash +npx @modelcontextprotocol/inspector node ./dist/src/cli.js stdio --app APP --external-user-id USER_ID +``` + +Open [http://localhost:5173/](http://localhost:5173/) and set the transport type to **STDIO**. + +![MCP inspector](./mcp-inspector.png) + +## Customization + +You can customize this implementation in any way you'd like, for example: + +1. Modifying `config.ts` to change default settings +2. Extending `registerComponentTools.ts` to add additional tools, or limit tools to a fixed set. +3. Improving the implementation to take advantage of [the latest version](https://spec.modelcontextprotocol.io/specification/2025-03-26/) of the MCP spec. +4. Persisting session data in Redis, or whatever data store you use. + +## License + +Pipedream Source Available License Version 1.0 - See https://github.com/PipedreamHQ/pipedream/blob/master/LICENSE diff --git a/modelcontextprotocol/lib/authProvisions.ts b/modelcontextprotocol/lib/authProvisions.ts new file mode 100644 index 0000000000000..65d9184905ec1 --- /dev/null +++ b/modelcontextprotocol/lib/authProvisions.ts @@ -0,0 +1,46 @@ +import { createPdClient } from "./pd-client.js" +import { config } from "./config.js" +import { Account } from "@pipedream/sdk" + +export const getAuthProvision = async ({ + app, + externalUserId, +}: { + app: string + externalUserId: string +}): Promise => { + const pd = createPdClient() + + // Get existing auth provisions for this user and app + const authProvisions = await pd.getAccounts({ + external_user_id: externalUserId, + include_credentials: false, + app, + }) + + // "healthy" auth provisions have active, valid OAuth grants / credentials + // This naive implementation returns the first healthy auth provision for the app + const authProvision = authProvisions.data.find((ap) => ap.healthy) + + // If no healthy auth provision exists, return a Pipedream-hosted link + // your users can use to connect their account. + // https://pipedream.com/docs/connect/managed-auth/connect-link/ + if (!authProvision) { + const token = await pd.createConnectToken({ + external_user_id: externalUserId, + webhook_uri: config.pipedream.webhookUri, + }) + + return ` +You need to connect your account to call this tool. + +Please visit this URL to securely authenticate with ${app}: + +https://pipedream.com/_static/connect.html?token=${token.token}&connectLink=true&app=${encodeURIComponent(app)} + +Let me know when you're done. + `.trim() + } + + return authProvision +} diff --git a/modelcontextprotocol/lib/config.ts b/modelcontextprotocol/lib/config.ts new file mode 100644 index 0000000000000..4f1e934b5308f --- /dev/null +++ b/modelcontextprotocol/lib/config.ts @@ -0,0 +1,42 @@ +/** + * Configuration for the MCP Reference Implementation + * You can override these settings using environment variables + */ + +interface PipedreamConfig { + clientId: string | undefined + clientSecret: string | undefined + projectId: string | undefined + environment: string | undefined + webhookUri: string | undefined +} + +interface Config { + defaultApp: string + serverPort: number + pipedream: PipedreamConfig +} + +export const config: Config = { + // Default app to use if none is specified + defaultApp: "slack", + + // Port for the SSE server + serverPort: 3010, + + // Pipedream configuration + pipedream: { + // Your Pipedream OAuth client credentials + clientId: process.env.PIPEDREAM_CLIENT_ID, + clientSecret: process.env.PIPEDREAM_CLIENT_SECRET, + + // Your Pipedream project ID + projectId: process.env.PIPEDREAM_PROJECT_ID, + + // Pipedream project environment + environment: process.env.PIPEDREAM_PROJECT_ENVIRONMENT || "development", + + // Webhook URI for OAuth callbacks + webhookUri: process.env.PIPEDREAM_WEBHOOK_URI, + }, +} diff --git a/modelcontextprotocol/lib/const.ts b/modelcontextprotocol/lib/const.ts new file mode 100644 index 0000000000000..e333318df759d --- /dev/null +++ b/modelcontextprotocol/lib/const.ts @@ -0,0 +1,2 @@ +// Tool name constants +export const CONFIGURE_COMPONENT_TOOL_NAME = "CONFIGURE_COMPONENT" diff --git a/modelcontextprotocol/lib/pd-client.ts b/modelcontextprotocol/lib/pd-client.ts new file mode 100644 index 0000000000000..f07c3c9d7a8eb --- /dev/null +++ b/modelcontextprotocol/lib/pd-client.ts @@ -0,0 +1,42 @@ +import { createBackendClient } from "@pipedream/sdk/server" +import { z } from "zod" +import { config } from "./config.js" + +// Pipedream API client +export const createPdClient = () => { + try { + const clientId = z.string().parse(config.pipedream.clientId) + const clientSecret = z.string().parse(config.pipedream.clientSecret) + const projectId = z.string().parse(config.pipedream.projectId) + const environment = z + .enum(["development", "production"]) + .parse(config.pipedream.environment) + + return createBackendClient({ + credentials: { + clientId, + clientSecret, + }, + projectId, + environment, + }) + } catch (error) { + console.error( + "Failed to create Pipedream client:", + error instanceof Error ? error.message : "Unknown error" + ) + console.error("Make sure you've set all required environment variables:") + console.error("- PIPEDREAM_CLIENT_ID (not shown for security)") + console.error("- PIPEDREAM_CLIENT_SECRET (not shown for security)") + console.error("- PIPEDREAM_PROJECT_ID (not shown for security)") + console.error("- PIPEDREAM_PROJECT_ENVIRONMENT (defaults to 'development')") + + // Create a more descriptive error message that includes original error + const errorMessage = + error instanceof Error + ? `Missing or invalid Pipedream configuration: ${error.message}` + : "Missing or invalid Pipedream configuration" + + throw new Error(errorMessage) + } +} diff --git a/modelcontextprotocol/lib/registerComponentTools.ts b/modelcontextprotocol/lib/registerComponentTools.ts new file mode 100644 index 0000000000000..3ede8542b9c81 --- /dev/null +++ b/modelcontextprotocol/lib/registerComponentTools.ts @@ -0,0 +1,231 @@ +import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js" +import { z, ZodRawShape } from "zod" +import { createPdClient } from "./pd-client.js" +import { RunActionOpts } from "@pipedream/sdk" +import { getAuthProvision } from "./authProvisions.js" +import { ConfigureComponentRawSchema } from "./schemas.js" +import { CONFIGURE_COMPONENT_TOOL_NAME } from "./const.js" + +interface SafeRegisterToolResult { + success: boolean + reason?: string +} + +export async function registerComponentTools({ + server, + app, + externalUserId, +}: { + server: McpServer + app: string + externalUserId: string +}): Promise { + // Create a single client instance to use throughout this function + const pd = createPdClient() + + // Helper function to safely register a tool, catching "already registered" errors + const safeRegisterTool = ( + name: string, + description: string, + schema: ZodRawShape, + handler: any + ): SafeRegisterToolResult => { + try { + server.tool(name, description, schema, handler) + return { success: true } + } catch (error) { + if ( + error instanceof Error && + error.message.includes("already registered") + ) { + return { success: false, reason: "already_registered" } + } + throw error // Re-throw any other errors + } + } + + // Get all available Pipedream components (pre-built triggers and actions) for the app + const components = await pd.getComponents({ + app, + componentType: "action", + }) + + // Register each component as a tool + for (const _component of components.data) { + const component = ( + await pd.getComponent({ + key: _component.key, + }) + ).data + + const schema: ZodRawShape = {} + + let configurablePropsDescription = "" + let appKey: string | undefined = undefined + + // Process the configurable properties (input) for the component + // https://pipedream.com/docs/workflows/contributing/components/api/#user-input-props + for (const cp of component.configurable_props) { + if (cp.type === "app") { + // Handle app type specially + appKey = cp.name + continue + } else if (cp.type === "string") { + schema[cp.name] = z.string() + } else if (cp.type === "string[]") { + schema[cp.name] = z + .union([ + z.string().transform((val) => { + try { + return JSON.parse(val) + } catch (e) { + return [val] // If not valid JSON, treat as single item array + } + }), + z.array(z.string()), + ]) + .refine((val) => Array.isArray(val), { + message: "Must be an array of strings", + }) + configurablePropsDescription += `- ${cp.name}: Return JSON in this format: string[]\n` + } else if (cp.type === "number") { + schema[cp.name] = z.number() + } else if (cp.type === "integer") { + schema[cp.name] = z.number().int() + } else if (cp.type === "boolean") { + schema[cp.name] = z.boolean() + } else { + console.error("unhandled type. Skipping", cp.name, cp.type) + } + + // Add optional flag and description to the schema + if (schema[cp.name]) { + if (cp.optional) { + schema[cp.name] = schema[cp.name].optional() + } + + let description: string = cp.description || "" + + if (cp.remoteOptions) { + description += `\n\nYou can use the "${CONFIGURE_COMPONENT_TOOL_NAME}" tool using these parameters to get the values. key: ${component.key}, propName: ${cp.name}` + if (cp.name.includes("id")) { + description += `\n\nIMPORTANT: An ID is required for this property. If you don't have the id and only have the name, use the "${CONFIGURE_COMPONENT_TOOL_NAME}" tool to get the values.` + } + } + + if (description.trim()) { + schema[cp.name] = schema[cp.name].describe(description.trim()) + } + } + } + + // Create the tool description + const description = ` +${component.description ?? "No description available"} + +${configurablePropsDescription ? "\n\n\n\nIMPORTANT: The arguments have specific formats. Please follow the instructions below:\n" + configurablePropsDescription : ""} + `.trim() + + // Register the tool for this component + safeRegisterTool(component.key, description, schema, async (_args: any) => { + const args = z.object(schema).parse(_args) + const authProvisionResponse = await getAuthProvision({ + app, + externalUserId, + }) + + if (typeof authProvisionResponse === "string") { + return { + content: [ + { + type: "text", + text: authProvisionResponse, + }, + ], + } + } + + // Run the action with the provided args + const requestOpts: RunActionOpts = { + actionId: { + key: component.key, + }, + configuredProps: { + ...args, + [appKey || app]: { + authProvisionId: authProvisionResponse.id, + }, + }, + externalUserId, + } + + console.log( + "Running action:", + component.key, + "for external user: [REDACTED]" + ) + const response = await pd.runAction(requestOpts) + + return { + content: [ + { + type: "text", + text: JSON.stringify(response, null, 2), + }, + ], + } + }) + } + + // Register the configure component tool, a special tool that allows progressive prop configuration + const configureComponentDescription = ` + You call this tool if you need to get the available options for a property of a component. + The property description will tell you if you can use this tool and what the parameter values are. + ` + safeRegisterTool( + CONFIGURE_COMPONENT_TOOL_NAME, + configureComponentDescription, + ConfigureComponentRawSchema, + async (_args: any) => { + const args = z.object(ConfigureComponentRawSchema).parse(_args) + const authProvisionResponse = await getAuthProvision({ + app, + externalUserId, + }) + + if (typeof authProvisionResponse === "string") { + return { + content: [ + { + type: "text", + text: authProvisionResponse, + }, + ], + } + } + + // Get the configuration options for this property + const response = await pd.configureComponent({ + componentId: { + key: args.componentKey, + }, + configuredProps: { + [app]: { + authProvisionId: authProvisionResponse.id, + }, + }, + externalUserId, + propName: args.propName, + }) + + return { + content: [ + { + type: "text", + text: JSON.stringify(response, null, 2), + }, + ], + } + } + ) +} diff --git a/modelcontextprotocol/lib/schemas.ts b/modelcontextprotocol/lib/schemas.ts new file mode 100644 index 0000000000000..7283731f1953a --- /dev/null +++ b/modelcontextprotocol/lib/schemas.ts @@ -0,0 +1,6 @@ +import { z } from "zod" + +export const ConfigureComponentRawSchema = { + componentKey: z.string(), + propName: z.string(), +} diff --git a/modelcontextprotocol/mcp-inspector.png b/modelcontextprotocol/mcp-inspector.png new file mode 100644 index 0000000000000000000000000000000000000000..1efde839403e5067f29e1fc6bdeb9ee02032c76f GIT binary patch literal 368705 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 @ebgPVO}(=V3cU&f}to-MuCpgZn;TeR-iCN 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∈b+ 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 z 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 J)LRdq{vWR=N6-KO literal 0 HcmV?d00001 diff --git a/modelcontextprotocol/package-lock.json b/modelcontextprotocol/package-lock.json new file mode 100644 index 0000000000000..7364075d88edb --- /dev/null +++ b/modelcontextprotocol/package-lock.json @@ -0,0 +1,1919 @@ +{ + "name": "@pipedream/mcp", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@pipedream/mcp", + "version": "1.0.0", + "dependencies": { + "@modelcontextprotocol/sdk": "^1.7.0", + "@pipedream/sdk": "^1.4.0", + "commander": "^13.1.0", + "cors": "^2.8.5", + "express": "^4.21.2", + "tsx": "^4.19.3", + "zod": "^3.24.2" + }, + "bin": { + "mcp": "dist/src/cli.js" + }, + "devDependencies": { + "@types/cors": "^2.8.17", + "@types/express": "^5.0.0", + "typescript": "^5.0.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.1.tgz", + "integrity": "sha512-kfYGy8IdzTGy+z0vFGvExZtxkFlA4zAxgKEahG9KE1ScBjpQnFsNOX8KTU5ojNru5ed5CVoJYXFtoxaq5nFbjQ==", + "cpu": [ + "ppc64" + ], + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.1.tgz", + "integrity": "sha512-dp+MshLYux6j/JjdqVLnMglQlFu+MuVeNrmT5nk6q07wNhCdSnB7QZj+7G8VMUGh1q+vj2Bq8kRsuyA00I/k+Q==", + "cpu": [ + "arm" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.1.tgz", + "integrity": "sha512-50tM0zCJW5kGqgG7fQ7IHvQOcAn9TKiVRuQ/lN0xR+T2lzEFvAi1ZcS8DiksFcEpf1t/GYOeOfCAgDHFpkiSmA==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.1.tgz", + "integrity": "sha512-GCj6WfUtNldqUzYkN/ITtlhwQqGWu9S45vUXs7EIYf+7rCiiqH9bCloatO9VhxsL0Pji+PF4Lz2XXCES+Q8hDw==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.1.tgz", + "integrity": "sha512-5hEZKPf+nQjYoSr/elb62U19/l1mZDdqidGfmFutVUjjUZrOazAtwK+Kr+3y0C/oeJfLlxo9fXb1w7L+P7E4FQ==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.1.tgz", + "integrity": "sha512-hxVnwL2Dqs3fM1IWq8Iezh0cX7ZGdVhbTfnOy5uURtao5OIVCEyj9xIzemDi7sRvKsuSdtCAhMKarxqtlyVyfA==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.1.tgz", + "integrity": "sha512-1MrCZs0fZa2g8E+FUo2ipw6jw5qqQiH+tERoS5fAfKnRx6NXH31tXBKI3VpmLijLH6yriMZsxJtaXUyFt/8Y4A==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.1.tgz", + "integrity": "sha512-0IZWLiTyz7nm0xuIs0q1Y3QWJC52R8aSXxe40VUxm6BB1RNmkODtW6LHvWRrGiICulcX7ZvyH6h5fqdLu4gkww==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.1.tgz", + "integrity": "sha512-NdKOhS4u7JhDKw9G3cY6sWqFcnLITn6SqivVArbzIaf3cemShqfLGHYMx8Xlm/lBit3/5d7kXvriTUGa5YViuQ==", + "cpu": [ + "arm" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.1.tgz", + "integrity": "sha512-jaN3dHi0/DDPelk0nLcXRm1q7DNJpjXy7yWaWvbfkPvI+7XNSc/lDOnCLN7gzsyzgu6qSAmgSvP9oXAhP973uQ==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.1.tgz", + "integrity": "sha512-OJykPaF4v8JidKNGz8c/q1lBO44sQNUQtq1KktJXdBLn1hPod5rE/Hko5ugKKZd+D2+o1a9MFGUEIUwO2YfgkQ==", + "cpu": [ + "ia32" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.1.tgz", + "integrity": "sha512-nGfornQj4dzcq5Vp835oM/o21UMlXzn79KobKlcs3Wz9smwiifknLy4xDCLUU0BWp7b/houtdrgUz7nOGnfIYg==", + "cpu": [ + "loong64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.1.tgz", + "integrity": "sha512-1osBbPEFYwIE5IVB/0g2X6i1qInZa1aIoj1TdL4AaAb55xIIgbg8Doq6a5BzYWgr+tEcDzYH67XVnTmUzL+nXg==", + "cpu": [ + "mips64el" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.1.tgz", + "integrity": "sha512-/6VBJOwUf3TdTvJZ82qF3tbLuWsscd7/1w+D9LH0W/SqUgM5/JJD0lrJ1fVIfZsqB6RFmLCe0Xz3fmZc3WtyVg==", + "cpu": [ + "ppc64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.1.tgz", + "integrity": "sha512-nSut/Mx5gnilhcq2yIMLMe3Wl4FK5wx/o0QuuCLMtmJn+WeWYoEGDN1ipcN72g1WHsnIbxGXd4i/MF0gTcuAjQ==", + "cpu": [ + "riscv64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.1.tgz", + "integrity": "sha512-cEECeLlJNfT8kZHqLarDBQso9a27o2Zd2AQ8USAEoGtejOrCYHNtKP8XQhMDJMtthdF4GBmjR2au3x1udADQQQ==", + "cpu": [ + "s390x" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.1.tgz", + "integrity": "sha512-xbfUhu/gnvSEg+EGovRc+kjBAkrvtk38RlerAzQxvMzlB4fXpCFCeUAYzJvrnhFtdeyVCDANSjJvOvGYoeKzFA==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.1.tgz", + "integrity": "sha512-O96poM2XGhLtpTh+s4+nP7YCCAfb4tJNRVZHfIE7dgmax+yMP2WgMd2OecBuaATHKTHsLWHQeuaxMRnCsH8+5g==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.1.tgz", + "integrity": "sha512-X53z6uXip6KFXBQ+Krbx25XHV/NCbzryM6ehOAeAil7X7oa4XIq+394PWGnwaSQ2WRA0KI6PUO6hTO5zeF5ijA==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.1.tgz", + "integrity": "sha512-Na9T3szbXezdzM/Kfs3GcRQNjHzM6GzFBeU1/6IV/npKP5ORtp9zbQjvkDJ47s6BCgaAZnnnu/cY1x342+MvZg==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.1.tgz", + "integrity": "sha512-T3H78X2h1tszfRSf+txbt5aOp/e7TAz3ptVKu9Oyir3IAOFPGV6O9c2naym5TOriy1l0nNf6a4X5UXRZSGX/dw==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.1.tgz", + "integrity": "sha512-2H3RUvcmULO7dIE5EWJH8eubZAI4xw54H1ilJnRNZdeo8dTADEZ21w6J22XBkXqGJbe0+wnNJtw3UXRoLJnFEg==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.1.tgz", + "integrity": "sha512-GE7XvrdOzrb+yVKB9KsRMq+7a2U/K5Cf/8grVFRAGJmfADr/e/ODQ134RK2/eeHqYV5eQRFxb1hY7Nr15fv1NQ==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.1.tgz", + "integrity": "sha512-uOxSJCIcavSiT6UnBhBzE8wy3n0hOkJsBOzy7HDAuTDE++1DJMRRVCPGisULScHL+a/ZwdXPpXD3IyFKjA7K8A==", + "cpu": [ + "ia32" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.1.tgz", + "integrity": "sha512-Y1EQdcfwMSeQN/ujR5VayLOJ1BHaK+ssyk0AEzPjC+t1lITgsnccPqFjb6V+LsTp/9Iov4ysfjxLaGJ9RPtkVg==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@modelcontextprotocol/sdk": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.7.0.tgz", + "integrity": "sha512-IYPe/FLpvF3IZrd/f5p5ffmWhMc3aEMuM2wGJASDqC2Ge7qatVCdbfPx3n/5xFeb19xN0j/911M2AaFuircsWA==", + "dependencies": { + "content-type": "^1.0.5", + "cors": "^2.8.5", + "eventsource": "^3.0.2", + "express": "^5.0.1", + "express-rate-limit": "^7.5.0", + "pkce-challenge": "^4.1.0", + "raw-body": "^3.0.0", + "zod": "^3.23.8", + "zod-to-json-schema": "^3.24.1" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/accepts": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", + "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==", + "dependencies": { + "mime-types": "^3.0.0", + "negotiator": "^1.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/body-parser": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.1.0.tgz", + "integrity": "sha512-/hPxh61E+ll0Ujp24Ilm64cykicul1ypfwjVttduAiEdtnJFvLePSrIPk+HMImtNv5270wOGCb1Tns2rybMkoQ==", + "dependencies": { + "bytes": "^3.1.2", + "content-type": "^1.0.5", + "debug": "^4.4.0", + "http-errors": "^2.0.0", + "iconv-lite": "^0.5.2", + "on-finished": "^2.4.1", + "qs": "^6.14.0", + "raw-body": "^3.0.0", + "type-is": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/body-parser/node_modules/debug": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz", + "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/body-parser/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/body-parser/node_modules/qs": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz", + "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/content-disposition": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz", + "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/cookie-signature": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", + "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", + "engines": { + "node": ">=6.6.0" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/debug": { + "version": "4.3.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.6.tgz", + "integrity": "sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/express": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/express/-/express-5.0.1.tgz", + "integrity": "sha512-ORF7g6qGnD+YtUG9yx4DFoqCShNMmUKiXuT5oWMHiOvt/4WFbHC6yCwQMTSBMno7AqntNCAzzcnnjowRkTL9eQ==", + "dependencies": { + "accepts": "^2.0.0", + "body-parser": "^2.0.1", + "content-disposition": "^1.0.0", + "content-type": "~1.0.4", + "cookie": "0.7.1", + "cookie-signature": "^1.2.1", + "debug": "4.3.6", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "^2.0.0", + "fresh": "2.0.0", + "http-errors": "2.0.0", + "merge-descriptors": "^2.0.0", + "methods": "~1.1.2", + "mime-types": "^3.0.0", + "on-finished": "2.4.1", + "once": "1.4.0", + "parseurl": "~1.3.3", + "proxy-addr": "~2.0.7", + "qs": "6.13.0", + "range-parser": "~1.2.1", + "router": "^2.0.0", + "safe-buffer": "5.2.1", + "send": "^1.1.0", + "serve-static": "^2.1.0", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "^2.0.0", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/finalhandler": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz", + "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==", + "dependencies": { + "debug": "^4.4.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "on-finished": "^2.4.1", + "parseurl": "^1.3.3", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/finalhandler/node_modules/debug": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz", + "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/finalhandler/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/fresh": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz", + "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/iconv-lite": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.5.2.tgz", + "integrity": "sha512-kERHXvpSaB4aU3eANwidg79K8FlrN77m8G9V+0vOR3HYaRifrlwMEpT7ZBJqLSEIHnEgJTHcWK82wwLwwKwtag==", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/media-typer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz", + "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/merge-descriptors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz", + "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/mime-db": { + "version": "1.54.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", + "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/mime-types": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.0.tgz", + "integrity": "sha512-XqoSHeCGjVClAmoGFG3lVFqQFRIrTVw2OH3axRqAcfaw+gHWIfnASS92AV+Rl/mk0MupgZTRHQOjxY6YVnzK5w==", + "dependencies": { + "mime-db": "^1.53.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/negotiator": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", + "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/send": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/send/-/send-1.1.0.tgz", + "integrity": "sha512-v67WcEouB5GxbTWL/4NeToqcZiAWEq90N888fczVArY8A79J0L4FD7vj5hm3eUMua5EpoQ59wa/oovY6TLvRUA==", + "dependencies": { + "debug": "^4.3.5", + "destroy": "^1.2.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "fresh": "^0.5.2", + "http-errors": "^2.0.0", + "mime-types": "^2.1.35", + "ms": "^2.1.3", + "on-finished": "^2.4.1", + "range-parser": "^1.2.1", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/send/node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/send/node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/send/node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/serve-static": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.1.0.tgz", + "integrity": "sha512-A3We5UfEjG8Z7VkDv6uItWw6HY2bBSBJT1KtVESn6EOoOr2jAxNhxWCLY3jDE2WcuHXByWju74ck3ZgLwL8xmA==", + "dependencies": { + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "parseurl": "^1.3.3", + "send": "^1.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@modelcontextprotocol/sdk/node_modules/type-is": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.0.tgz", + "integrity": "sha512-gd0sGezQYCbWSbkZr75mln4YBidWUN60+devscpLF5mtRDUpiaTvKpBNrdaCvel1NdR2k6vclXybU5fBd2i+nw==", + "dependencies": { + "content-type": "^1.0.5", + "media-typer": "^1.1.0", + "mime-types": "^3.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@pipedream/sdk": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@pipedream/sdk/-/sdk-1.4.0.tgz", + "integrity": "sha512-mVjYoDF6MNOWMi+UjzAz7T8GgjHI1f9IrPFhfd0VH968QP9k1HtJDfEZFhfJf+hKxKFCT8XRE7npJAX8efr0uw==", + "dependencies": { + "@rails/actioncable": "^8.0.0", + "commander": "^12.1.0", + "oauth4webapi": "^3.1.4", + "ws": "^8.18.0" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@pipedream/sdk/node_modules/commander": { + "version": "12.1.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-12.1.0.tgz", + "integrity": "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==", + "engines": { + "node": ">=18" + } + }, + "node_modules/@rails/actioncable": { + "version": "8.0.200", + "resolved": "https://registry.npmjs.org/@rails/actioncable/-/actioncable-8.0.200.tgz", + "integrity": "sha512-EDqWyxck22BHmv1e+mD8Kl6GmtNkhEPdRfGFT7kvsv1yoXd9iYrqHDVAaR8bKmU/syC5eEZ2I5aWWxtB73ukMw==" + }, + "node_modules/@types/body-parser": { + "version": "1.19.5", + "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz", + "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==", + "dev": true, + "dependencies": { + "@types/connect": "*", + "@types/node": "*" + } + }, + "node_modules/@types/connect": { + "version": "3.4.38", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz", + "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/cors": { + "version": "2.8.17", + "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.17.tgz", + "integrity": "sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/express": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@types/express/-/express-5.0.1.tgz", + "integrity": "sha512-UZUw8vjpWFXuDnjFTh7/5c2TWDlQqeXHi6hcN7F2XSVT5P+WmUnnbFS3KA6Jnc6IsEqI2qCVu2bK0R0J4A8ZQQ==", + "dev": true, + "dependencies": { + "@types/body-parser": "*", + "@types/express-serve-static-core": "^5.0.0", + "@types/serve-static": "*" + } + }, + "node_modules/@types/express-serve-static-core": { + "version": "5.0.6", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.0.6.tgz", + "integrity": "sha512-3xhRnjJPkULekpSzgtoNYYcTWgEZkp4myc+Saevii5JPnHNvHMRlBSHDbs7Bh1iPPoVTERHEZXyhyLbMEsExsA==", + "dev": true, + "dependencies": { + "@types/node": "*", + "@types/qs": "*", + "@types/range-parser": "*", + "@types/send": "*" + } + }, + "node_modules/@types/http-errors": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz", + "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==", + "dev": true + }, + "node_modules/@types/mime": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz", + "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==", + "dev": true + }, + "node_modules/@types/node": { + "version": "22.13.13", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.13.13.tgz", + "integrity": "sha512-ClsL5nMwKaBRwPcCvH8E7+nU4GxHVx1axNvMZTFHMEfNI7oahimt26P5zjVCRrjiIWj6YFXfE1v3dEp94wLcGQ==", + "dev": true, + "dependencies": { + "undici-types": "~6.20.0" + } + }, + "node_modules/@types/qs": { + "version": "6.9.18", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.18.tgz", + "integrity": "sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA==", + "dev": true + }, + "node_modules/@types/range-parser": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz", + "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==", + "dev": true + }, + "node_modules/@types/send": { + "version": "0.17.4", + "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz", + "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==", + "dev": true, + "dependencies": { + "@types/mime": "^1", + "@types/node": "*" + } + }, + "node_modules/@types/serve-static": { + "version": "1.15.7", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz", + "integrity": "sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==", + "dev": true, + "dependencies": { + "@types/http-errors": "*", + "@types/node": "*", + "@types/send": "*" + } + }, + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==" + }, + "node_modules/body-parser": { + "version": "1.20.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz", + "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.13.0", + "raw-body": "2.5.2", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/body-parser/node_modules/raw-body": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", + "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/commander": { + "version": "13.1.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz", + "integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==", + "engines": { + "node": ">=18" + } + }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz", + "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==" + }, + "node_modules/cors": { + "version": "2.8.5", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz", + "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/esbuild": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.1.tgz", + "integrity": "sha512-BGO5LtrGC7vxnqucAe/rmvKdJllfGaYWdyABvyMoXQlfYMb2bbRuReWR5tEGE//4LcNJj9XrkovTqNYRFZHAMQ==", + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.1", + "@esbuild/android-arm": "0.25.1", + "@esbuild/android-arm64": "0.25.1", + "@esbuild/android-x64": "0.25.1", + "@esbuild/darwin-arm64": "0.25.1", + "@esbuild/darwin-x64": "0.25.1", + "@esbuild/freebsd-arm64": "0.25.1", + "@esbuild/freebsd-x64": "0.25.1", + "@esbuild/linux-arm": "0.25.1", + "@esbuild/linux-arm64": "0.25.1", + "@esbuild/linux-ia32": "0.25.1", + "@esbuild/linux-loong64": "0.25.1", + "@esbuild/linux-mips64el": "0.25.1", + "@esbuild/linux-ppc64": "0.25.1", + "@esbuild/linux-riscv64": "0.25.1", + "@esbuild/linux-s390x": "0.25.1", + "@esbuild/linux-x64": "0.25.1", + "@esbuild/netbsd-arm64": "0.25.1", + "@esbuild/netbsd-x64": "0.25.1", + "@esbuild/openbsd-arm64": "0.25.1", + "@esbuild/openbsd-x64": "0.25.1", + "@esbuild/sunos-x64": "0.25.1", + "@esbuild/win32-arm64": "0.25.1", + "@esbuild/win32-ia32": "0.25.1", + "@esbuild/win32-x64": "0.25.1" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==" + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/eventsource": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.5.tgz", + "integrity": "sha512-LT/5J605bx5SNyE+ITBDiM3FxffBiq9un7Vx0EwMDM3vg8sWKx/tO2zC+LMqZ+smAM0F2hblaDZUVZF0te2pSw==", + "dependencies": { + "eventsource-parser": "^3.0.0" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/eventsource-parser": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.0.tgz", + "integrity": "sha512-T1C0XCUimhxVQzW4zFipdx0SficT651NnkR0ZSH3yQwh+mFMdLfgjABVi4YtMTtaL4s168593DaoaRLMqryavA==", + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/express": { + "version": "4.21.2", + "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz", + "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "1.20.3", + "content-disposition": "0.5.4", + "content-type": "~1.0.4", + "cookie": "0.7.1", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.3.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "0.1.12", + "proxy-addr": "~2.0.7", + "qs": "6.13.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "0.19.0", + "serve-static": "1.16.2", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express-rate-limit": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.0.tgz", + "integrity": "sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg==", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/express-rate-limit" + }, + "peerDependencies": { + "express": "^4.11 || 5 || ^5.0.0-beta.1" + } + }, + "node_modules/finalhandler": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz", + "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "statuses": "2.0.1", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-tsconfig": { + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.0.tgz", + "integrity": "sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A==", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/http-errors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "dependencies": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-promise": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz", + "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==" + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/oauth4webapi": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/oauth4webapi/-/oauth4webapi-3.3.1.tgz", + "integrity": "sha512-ZwX7UqYrP3Lr+Glhca3a1/nF2jqf7VVyJfhGuW5JtrfDUxt0u+IoBPzFjZ2dd7PJGkdM6CFPVVYzuDYKHv101A==", + "funding": { + "url": "https://github.com/sponsors/panva" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==" + }, + "node_modules/pkce-challenge": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-4.1.0.tgz", + "integrity": "sha512-ZBmhE1C9LcPoH9XZSdwiPtbPHZROwAnMy+kIFQVrnMCxY4Cudlz3gBOpzilgc0jOgRaiT3sIWfpMomW2ar2orQ==", + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/qs": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz", + "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==", + "dependencies": { + "side-channel": "^1.0.6" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz", + "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.6.3", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/raw-body/node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/router": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/router/-/router-2.1.0.tgz", + "integrity": "sha512-/m/NSLxeYEgWNtyC+WtNHCF7jbGxOibVWKnn+1Psff4dJGOfoXP+MuC/f2CwSmyiHdOIzYnYFp4W6GxWfekaLA==", + "dependencies": { + "is-promise": "^4.0.0", + "parseurl": "^1.3.3", + "path-to-regexp": "^8.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/router/node_modules/path-to-regexp": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz", + "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==", + "engines": { + "node": ">=16" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "node_modules/send": { + "version": "0.19.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", + "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + }, + "node_modules/serve-static": { + "version": "1.16.2", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz", + "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "0.19.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==" + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/statuses": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tsx": { + "version": "4.19.3", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.19.3.tgz", + "integrity": "sha512-4H8vUNGNjQ4V2EOoGw005+c+dGuPSnhpPBPHBtsZdGZBk/iJb4kguGlPWaZTZ3q5nMtFOEsY0nRDlh9PJyd6SQ==", + "dependencies": { + "esbuild": "~0.25.0", + "get-tsconfig": "^4.7.5" + }, + "bin": { + "tsx": "dist/cli.mjs" + }, + "engines": { + "node": ">=18.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + } + }, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typescript": { + "version": "5.8.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.2.tgz", + "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==", + "dev": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz", + "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==", + "dev": true + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + }, + "node_modules/ws": { + "version": "8.18.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz", + "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/zod": { + "version": "3.24.2", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz", + "integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-to-json-schema": { + "version": "3.24.5", + "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.5.tgz", + "integrity": "sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==", + "peerDependencies": { + "zod": "^3.24.1" + } + } + } +} diff --git a/modelcontextprotocol/package.json b/modelcontextprotocol/package.json new file mode 100644 index 0000000000000..66dcfc52f5859 --- /dev/null +++ b/modelcontextprotocol/package.json @@ -0,0 +1,35 @@ +{ + "name": "@pipedream/mcp", + "version": "0.0.1", + "description": "Pipedream stdio and SSE MCP servers", + "type": "module", + "bin": { + "@pipedream/mcp": "./dist/src/cli.js" + }, + "scripts": { + "dev:stdio": "tsx watch src/stdio.ts", + "dev:sse": "tsx watch src/sse.ts", + "start:stdio": "tsx src/cli.ts stdio", + "start:sse": "tsx src/cli.ts sse", + "start:stdio:app": "tsx src/cli.ts stdio --app", + "start:sse:app": "tsx src/cli.ts sse --app", + "build": "tsc", + "prepare": "npm run build", + "start:stdio:prod": "node dist/src/cli.js stdio", + "start:sse:prod": "node dist/src/cli.js sse" + }, + "dependencies": { + "@modelcontextprotocol/sdk": "^1.7.0", + "@pipedream/sdk": "^1.4.0", + "commander": "^13.1.0", + "cors": "^2.8.5", + "express": "^4.21.2", + "zod": "^3.24.2" + }, + "devDependencies": { + "@types/cors": "^2.8.17", + "@types/express": "^5.0.0", + "tsx": "^4.19.3", + "typescript": "^5.0.0" + } +} diff --git a/modelcontextprotocol/src/cli.ts b/modelcontextprotocol/src/cli.ts new file mode 100644 index 0000000000000..a0db3be536100 --- /dev/null +++ b/modelcontextprotocol/src/cli.ts @@ -0,0 +1,56 @@ +#!/usr/bin/env node + +import { Command } from "commander" +import fs from "fs" +import path from "path" +import { fileURLToPath } from "url" + +// Get package.json version in ESM +const __filename = fileURLToPath(import.meta.url) +const __dirname = path.dirname(__filename) +const packageJson = JSON.parse( + fs.readFileSync(path.join(__dirname, "../../package.json"), "utf8") +) +const version = packageJson.version + +const program = new Command() + +program + .name("@pipedream/mcp") + .description("Pipedream MCP server CLI") + .version(version) + +program + .command("stdio") + .description("Start the stdio server") + .requiredOption("--app ", "Specify the MCP app name") + .option( + "--external-user-id ", + "Specify the external user ID (defaults to a random UUID)" + ) + .action(async (options) => { + try { + const { main } = await import("./stdio.js") + await main(options.app, options.externalUserId) + } catch (error) { + console.error("Error starting stdio server:", error) + process.exit(1) + } + }) + +program + .command("sse") + .description("Start the SSE server (default port: 3010)") + .option("--app ", "Specify the MCP app name") + .option("--port ", "Specify the port to run the server on") + .action(async (options) => { + try { + const { main } = await import("./sse.js") + await main(options.app, options.port) + } catch (error) { + console.error("Error starting SSE server:", error) + process.exit(1) + } + }) + +program.parse() diff --git a/modelcontextprotocol/src/mcp-server.ts b/modelcontextprotocol/src/mcp-server.ts new file mode 100644 index 0000000000000..169f15d60664b --- /dev/null +++ b/modelcontextprotocol/src/mcp-server.ts @@ -0,0 +1,23 @@ +import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js" +import { registerComponentTools } from "../lib/registerComponentTools.js" + +export const serverFactory = async ({ + app, + externalUserId, +}: { + app: string + externalUserId: string +}) => { + const server = new McpServer({ + name: "pipedream-connect", + version: "1.0.0", + }) + + await registerComponentTools({ + server, + app, + externalUserId, + }) + + return server +} diff --git a/modelcontextprotocol/src/sse.ts b/modelcontextprotocol/src/sse.ts new file mode 100644 index 0000000000000..ab8509d89161c --- /dev/null +++ b/modelcontextprotocol/src/sse.ts @@ -0,0 +1,191 @@ +import express from "express" +import cors from "cors" +import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js" +import { serverFactory } from "./mcp-server.js" +import { fileURLToPath } from "url" +import { config } from "../lib/config.js" + +// In a production environment, you'd handle sessions in Redis +// or another persistent store, rather than in memory +const transports = new Map() + +// Helper function to create transport without setting headers +// (headers will be set by transport.start() when called by server.connect()) +const setupSSEConnection = (res: express.Response, messagePath: string) => { + console.log("Creating SSE transport") + const transport = new SSEServerTransport(messagePath, res) + transports.set(transport.sessionId, transport) + return transport +} + +export async function main(appName?: string, portOption?: string) { + const app = express() + + // Log all requests for debugging + app.use((req, res, next) => { + console.log( + `Received ${req.method} request for ${req.url.replace(/\/[^/]+\//, "/[REDACTED]/")}` + ) + next() + }) + + app.use(cors()) // Enable CORS for all origins + app.use(express.json()) + + // Use provided port or fallback to env var or default from config + const port = portOption || process.env.PORT || config.serverPort + + app.get("/", (req, res) => { + console.log("Health check") + res.send("Hello World") + }) + + // Define reusable handlers to avoid code duplication + const handleSSEConnection = async ( + req: express.Request, + res: express.Response, + appName: string + ) => { + const messagePath = `/${req.params.external_user_id}/${appName}/messages` + const transport = setupSSEConnection(res, messagePath) + + try { + console.log( + `Starting serverFactory for app: ${appName}, external_user_id: [REDACTED]` + ) + const server = await serverFactory({ + app: appName, + externalUserId: req.params.external_user_id, + }) + console.log("Server factory successful, connecting transport") + await server.connect(transport) + + console.log("Connected to MCP server") + + req.on("close", () => { + console.log("SSE connection closed") + transports.delete(transport.sessionId) + }) + } catch (error) { + console.error("Error connecting to MCP server:", error) + if (error instanceof Error) { + console.error(error.stack) + res + .status(500) + .end(`Failed to establish SSE connection: ${error.message}`) + } else { + // For non-Error objects that were thrown + res + .status(500) + .end(`Failed to establish SSE connection: ${String(error)}`) + } + } + } + + const handlePostMessage = async ( + req: express.Request, + res: express.Response + ) => { + if (!req.query.sessionId || typeof req.query.sessionId !== "string") { + res.status(400).json({ error: "Invalid sessionId" }) + return + } + + const transport = transports.get(req.query.sessionId) + if (!transport) { + console.log("No transport found") + res.status(500).json({ error: "No SSE connection established" }) + return + } + + try { + await transport.handlePostMessage(req, res, req.body) + console.log("Message handled successfully") + return + } catch (error) { + console.error("Error handling message:", error) + if (error instanceof Error) { + console.error(error.stack) + res.status(500).json({ error: error.message }) + } else { + // For non-Error objects that were thrown + res.status(500).json({ error: String(error) }) + } + return + } + } + + if (appName) { + // If app is explicitly passed via CLI, set up specific routes for that app only + app.get(`/:external_user_id/${appName}`, async (req, res) => { + console.log(`GET /:external_user_id/${appName}`) + await handleSSEConnection(req, res, appName) + }) + + app.post(`/:external_user_id/${appName}/messages`, async (req, res) => { + console.log( + `POST /:external_user_id/${appName}/messages`, + "[REDACTED]" // Redacted sessionId + ) + await handlePostMessage(req, res) + }) + } else { + // Generic routes for any app + app.get("/:external_user_id/:app", async (req, res) => { + console.log(`GET /:external_user_id/[REDACTED] (app: ${req.params.app})`) + await handleSSEConnection(req, res, req.params.app) + }) + + app.post("/:external_user_id/:app/messages", async (req, res) => { + console.log("POST /:external_user_id/:app/messages", "[REDACTED]") // Redacted sessionId + await handlePostMessage(req, res) + }) + } + + app.on("error", (err) => { + console.error(err) + }) + + // Add a global error handler to catch unhandled promise rejections + process.on("unhandledRejection", (reason, promise) => { + console.error("Unhandled Rejection at:", promise, "reason:", reason) + }) + + app + .listen(port, () => { + console.log(`Server is running on port ${port}`) + console.log("Routes configured:") + console.log("- GET / - Health check") + if (appName) { + console.log( + `- GET /:external_user_id/${appName} - App-specific SSE connection endpoint` + ) + console.log( + `- POST /:external_user_id/${appName}/messages - App-specific message handler` + ) + } else { + console.log( + "- GET /:external_user_id/:app - App-specific SSE connection endpoint" + ) + console.log( + "- POST /:external_user_id/:app/messages - App-specific message handler" + ) + } + }) + .on("error", (err) => { + console.error("Server startup error:", err) + }) +} + +// Only auto-start if this module is the entry point +// In ES modules, we need to check if the current file URL is the same as import.meta.url + +// Check if this file is being run directly +const isMainModule = process.argv[1] === fileURLToPath(import.meta.url) + +if (isMainModule) { + main().catch((error) => { + console.error("Fatal error in main():", error) + process.exit(1) + }) +} diff --git a/modelcontextprotocol/src/stdio.ts b/modelcontextprotocol/src/stdio.ts new file mode 100644 index 0000000000000..2fa7cc5088804 --- /dev/null +++ b/modelcontextprotocol/src/stdio.ts @@ -0,0 +1,44 @@ +import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js" +import { serverFactory } from "./mcp-server.js" +import { randomUUID } from "crypto" +import { fileURLToPath } from "url" + +export async function main(appName: string, externalUserId?: string) { + if (!appName) { + throw new Error("App name is required for stdio server") + } + + const transport = new StdioServerTransport() + + // Use provided external user ID or generate a random UUID + const userId = externalUserId || randomUUID() + + const server = await serverFactory({ + // The app slug (app ID) — https://pipedream.com/docs/rest-api/#list-apps + app: appName, + // This is your user's ID, in your system — whatever you use to uniquely identify them. + // See https://pipedream.com/docs/connect/api/#external-users + externalUserId: userId, + }) + await server.connect(transport) + console.error( + `pd-connect MCP Server running on stdio for app: ${appName}, external_user_id: ${userId}` + ) +} + +// Check if this file is being run directly +const isMainModule = process.argv[1] === fileURLToPath(import.meta.url) + +if (isMainModule) { + // When run directly, require APP env var + const appName = process.env.APP + if (!appName) { + console.error("Error: APP environment variable is required") + process.exit(1) + } + + main(appName).catch((error) => { + console.error("Fatal error in main():", error) + process.exit(1) + }) +} diff --git a/modelcontextprotocol/tsconfig.json b/modelcontextprotocol/tsconfig.json new file mode 100644 index 0000000000000..f7aa7e9ed8bf9 --- /dev/null +++ b/modelcontextprotocol/tsconfig.json @@ -0,0 +1,16 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "NodeNext", + "moduleResolution": "NodeNext", + "esModuleInterop": true, + "strict": true, + "skipLibCheck": true, + "outDir": "dist", + "rootDir": ".", + "declaration": true, + "resolveJsonModule": true + }, + "include": ["src/**/*", "lib/**/*"], + "exclude": ["node_modules", "dist"] +} \ No newline at end of file diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 40739b5c127cf..32e09a5d845c5 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -8625,8 +8625,7 @@ importers: components/nutrient_document_web_services_api: {} - components/nutrient_workflow_automation: - specifiers: {} + components/nutrient_workflow_automation: {} components/nutshell: dependencies: @@ -8952,8 +8951,7 @@ importers: components/optimoroute: {} - components/oracle_cloud_infrastructure: - specifiers: {} + components/oracle_cloud_infrastructure: {} components/orbisx: {} From 21ab744e737c8dae9c1e9d95b424355fbcb0114f Mon Sep 17 00:00:00 2001 From: "Dylan J. Sather" Date: Thu, 27 Mar 2025 20:36:25 -0700 Subject: [PATCH 2/3] ESLint --- modelcontextprotocol/lib/pd-client.ts | 9 +++-- .../lib/registerComponentTools.ts | 32 ++++++++++++----- modelcontextprotocol/package-lock.json | 36 +++++++++++++++++-- modelcontextprotocol/src/cli.ts | 4 +-- modelcontextprotocol/src/sse.ts | 34 +++++++++++------- modelcontextprotocol/src/stdio.ts | 2 +- modelcontextprotocol/tsconfig.json | 2 +- 7 files changed, 88 insertions(+), 31 deletions(-) diff --git a/modelcontextprotocol/lib/pd-client.ts b/modelcontextprotocol/lib/pd-client.ts index f07c3c9d7a8eb..564262ee6a4dc 100644 --- a/modelcontextprotocol/lib/pd-client.ts +++ b/modelcontextprotocol/lib/pd-client.ts @@ -9,7 +9,10 @@ export const createPdClient = () => { const clientSecret = z.string().parse(config.pipedream.clientSecret) const projectId = z.string().parse(config.pipedream.projectId) const environment = z - .enum(["development", "production"]) + .enum([ + "development", + "production", + ]) .parse(config.pipedream.environment) return createBackendClient({ @@ -23,7 +26,9 @@ export const createPdClient = () => { } catch (error) { console.error( "Failed to create Pipedream client:", - error instanceof Error ? error.message : "Unknown error" + error instanceof Error + ? error.message + : "Unknown error", ) console.error("Make sure you've set all required environment variables:") console.error("- PIPEDREAM_CLIENT_ID (not shown for security)") diff --git a/modelcontextprotocol/lib/registerComponentTools.ts b/modelcontextprotocol/lib/registerComponentTools.ts index 3ede8542b9c81..8c06262c03555 100644 --- a/modelcontextprotocol/lib/registerComponentTools.ts +++ b/modelcontextprotocol/lib/registerComponentTools.ts @@ -1,5 +1,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js" -import { z, ZodRawShape } from "zod" +import { + z, ZodRawShape, +} from "zod" import { createPdClient } from "./pd-client.js" import { RunActionOpts } from "@pipedream/sdk" import { getAuthProvision } from "./authProvisions.js" @@ -28,17 +30,23 @@ export async function registerComponentTools({ name: string, description: string, schema: ZodRawShape, - handler: any + // eslint-disable-next-line @typescript-eslint/no-explicit-any + handler: any, ): SafeRegisterToolResult => { try { server.tool(name, description, schema, handler) - return { success: true } + return { + success: true, + } } catch (error) { if ( error instanceof Error && error.message.includes("already registered") ) { - return { success: false, reason: "already_registered" } + return { + success: false, + reason: "already_registered", + } } throw error // Re-throw any other errors } @@ -78,8 +86,10 @@ export async function registerComponentTools({ z.string().transform((val) => { try { return JSON.parse(val) - } catch (e) { - return [val] // If not valid JSON, treat as single item array + } catch { + return [ + val, + ] // If not valid JSON, treat as single item array } }), z.array(z.string()), @@ -123,10 +133,13 @@ export async function registerComponentTools({ const description = ` ${component.description ?? "No description available"} -${configurablePropsDescription ? "\n\n\n\nIMPORTANT: The arguments have specific formats. Please follow the instructions below:\n" + configurablePropsDescription : ""} +${configurablePropsDescription + ? "\n\n\n\nIMPORTANT: The arguments have specific formats. Please follow the instructions below:\n" + configurablePropsDescription + : ""} `.trim() // Register the tool for this component + // eslint-disable-next-line @typescript-eslint/no-explicit-any safeRegisterTool(component.key, description, schema, async (_args: any) => { const args = z.object(schema).parse(_args) const authProvisionResponse = await getAuthProvision({ @@ -162,7 +175,7 @@ ${configurablePropsDescription ? "\n\n\n\nIMPORTANT: The arguments have specific console.log( "Running action:", component.key, - "for external user: [REDACTED]" + "for external user: [REDACTED]", ) const response = await pd.runAction(requestOpts) @@ -186,6 +199,7 @@ ${configurablePropsDescription ? "\n\n\n\nIMPORTANT: The arguments have specific CONFIGURE_COMPONENT_TOOL_NAME, configureComponentDescription, ConfigureComponentRawSchema, + // eslint-disable-next-line @typescript-eslint/no-explicit-any async (_args: any) => { const args = z.object(ConfigureComponentRawSchema).parse(_args) const authProvisionResponse = await getAuthProvision({ @@ -226,6 +240,6 @@ ${configurablePropsDescription ? "\n\n\n\nIMPORTANT: The arguments have specific }, ], } - } + }, ) } diff --git a/modelcontextprotocol/package-lock.json b/modelcontextprotocol/package-lock.json index 7364075d88edb..69be4c7e36c75 100644 --- a/modelcontextprotocol/package-lock.json +++ b/modelcontextprotocol/package-lock.json @@ -1,19 +1,18 @@ { "name": "@pipedream/mcp", - "version": "1.0.0", + "version": "0.0.1", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@pipedream/mcp", - "version": "1.0.0", + "version": "0.0.1", "dependencies": { "@modelcontextprotocol/sdk": "^1.7.0", "@pipedream/sdk": "^1.4.0", "commander": "^13.1.0", "cors": "^2.8.5", "express": "^4.21.2", - "tsx": "^4.19.3", "zod": "^3.24.2" }, "bin": { @@ -22,6 +21,7 @@ "devDependencies": { "@types/cors": "^2.8.17", "@types/express": "^5.0.0", + "tsx": "^4.19.3", "typescript": "^5.0.0" } }, @@ -32,6 +32,7 @@ "cpu": [ "ppc64" ], + "dev": true, "optional": true, "os": [ "aix" @@ -47,6 +48,7 @@ "cpu": [ "arm" ], + "dev": true, "optional": true, "os": [ "android" @@ -62,6 +64,7 @@ "cpu": [ "arm64" ], + "dev": true, "optional": true, "os": [ "android" @@ -77,6 +80,7 @@ "cpu": [ "x64" ], + "dev": true, "optional": true, "os": [ "android" @@ -92,6 +96,7 @@ "cpu": [ "arm64" ], + "dev": true, "optional": true, "os": [ "darwin" @@ -107,6 +112,7 @@ "cpu": [ "x64" ], + "dev": true, "optional": true, "os": [ "darwin" @@ -122,6 +128,7 @@ "cpu": [ "arm64" ], + "dev": true, "optional": true, "os": [ "freebsd" @@ -137,6 +144,7 @@ "cpu": [ "x64" ], + "dev": true, "optional": true, "os": [ "freebsd" @@ -152,6 +160,7 @@ "cpu": [ "arm" ], + "dev": true, "optional": true, "os": [ "linux" @@ -167,6 +176,7 @@ "cpu": [ "arm64" ], + "dev": true, "optional": true, "os": [ "linux" @@ -182,6 +192,7 @@ "cpu": [ "ia32" ], + "dev": true, "optional": true, "os": [ "linux" @@ -197,6 +208,7 @@ "cpu": [ "loong64" ], + "dev": true, "optional": true, "os": [ "linux" @@ -212,6 +224,7 @@ "cpu": [ "mips64el" ], + "dev": true, "optional": true, "os": [ "linux" @@ -227,6 +240,7 @@ "cpu": [ "ppc64" ], + "dev": true, "optional": true, "os": [ "linux" @@ -242,6 +256,7 @@ "cpu": [ "riscv64" ], + "dev": true, "optional": true, "os": [ "linux" @@ -257,6 +272,7 @@ "cpu": [ "s390x" ], + "dev": true, "optional": true, "os": [ "linux" @@ -272,6 +288,7 @@ "cpu": [ "x64" ], + "dev": true, "optional": true, "os": [ "linux" @@ -287,6 +304,7 @@ "cpu": [ "arm64" ], + "dev": true, "optional": true, "os": [ "netbsd" @@ -302,6 +320,7 @@ "cpu": [ "x64" ], + "dev": true, "optional": true, "os": [ "netbsd" @@ -317,6 +336,7 @@ "cpu": [ "arm64" ], + "dev": true, "optional": true, "os": [ "openbsd" @@ -332,6 +352,7 @@ "cpu": [ "x64" ], + "dev": true, "optional": true, "os": [ "openbsd" @@ -347,6 +368,7 @@ "cpu": [ "x64" ], + "dev": true, "optional": true, "os": [ "sunos" @@ -362,6 +384,7 @@ "cpu": [ "arm64" ], + "dev": true, "optional": true, "os": [ "win32" @@ -377,6 +400,7 @@ "cpu": [ "ia32" ], + "dev": true, "optional": true, "os": [ "win32" @@ -392,6 +416,7 @@ "cpu": [ "x64" ], + "dev": true, "optional": true, "os": [ "win32" @@ -1105,6 +1130,7 @@ "version": "0.25.1", "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.1.tgz", "integrity": "sha512-BGO5LtrGC7vxnqucAe/rmvKdJllfGaYWdyABvyMoXQlfYMb2bbRuReWR5tEGE//4LcNJj9XrkovTqNYRFZHAMQ==", + "dev": true, "hasInstallScript": true, "bin": { "esbuild": "bin/esbuild" @@ -1268,6 +1294,7 @@ "version": "2.3.3", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, "hasInstallScript": true, "optional": true, "os": [ @@ -1324,6 +1351,7 @@ "version": "4.10.0", "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.0.tgz", "integrity": "sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A==", + "dev": true, "dependencies": { "resolve-pkg-maps": "^1.0.0" }, @@ -1613,6 +1641,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "dev": true, "funding": { "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" } @@ -1805,6 +1834,7 @@ "version": "4.19.3", "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.19.3.tgz", "integrity": "sha512-4H8vUNGNjQ4V2EOoGw005+c+dGuPSnhpPBPHBtsZdGZBk/iJb4kguGlPWaZTZ3q5nMtFOEsY0nRDlh9PJyd6SQ==", + "dev": true, "dependencies": { "esbuild": "~0.25.0", "get-tsconfig": "^4.7.5" diff --git a/modelcontextprotocol/src/cli.ts b/modelcontextprotocol/src/cli.ts index a0db3be536100..a384f3e6c28be 100644 --- a/modelcontextprotocol/src/cli.ts +++ b/modelcontextprotocol/src/cli.ts @@ -9,7 +9,7 @@ import { fileURLToPath } from "url" const __filename = fileURLToPath(import.meta.url) const __dirname = path.dirname(__filename) const packageJson = JSON.parse( - fs.readFileSync(path.join(__dirname, "../../package.json"), "utf8") + fs.readFileSync(path.join(__dirname, "../../package.json"), "utf8"), ) const version = packageJson.version @@ -26,7 +26,7 @@ program .requiredOption("--app ", "Specify the MCP app name") .option( "--external-user-id ", - "Specify the external user ID (defaults to a random UUID)" + "Specify the external user ID (defaults to a random UUID)", ) .action(async (options) => { try { diff --git a/modelcontextprotocol/src/sse.ts b/modelcontextprotocol/src/sse.ts index ab8509d89161c..03ed9283ea0d3 100644 --- a/modelcontextprotocol/src/sse.ts +++ b/modelcontextprotocol/src/sse.ts @@ -24,7 +24,7 @@ export async function main(appName?: string, portOption?: string) { // Log all requests for debugging app.use((req, res, next) => { console.log( - `Received ${req.method} request for ${req.url.replace(/\/[^/]+\//, "/[REDACTED]/")}` + `Received ${req.method} request for ${req.url.replace(/\/[^/]+\//, "/[REDACTED]/")}`, ) next() }) @@ -44,14 +44,14 @@ export async function main(appName?: string, portOption?: string) { const handleSSEConnection = async ( req: express.Request, res: express.Response, - appName: string + appName: string, ) => { const messagePath = `/${req.params.external_user_id}/${appName}/messages` const transport = setupSSEConnection(res, messagePath) try { console.log( - `Starting serverFactory for app: ${appName}, external_user_id: [REDACTED]` + `Starting serverFactory for app: ${appName}, external_user_id: [REDACTED]`, ) const server = await serverFactory({ app: appName, @@ -84,17 +84,21 @@ export async function main(appName?: string, portOption?: string) { const handlePostMessage = async ( req: express.Request, - res: express.Response + res: express.Response, ) => { if (!req.query.sessionId || typeof req.query.sessionId !== "string") { - res.status(400).json({ error: "Invalid sessionId" }) + res.status(400).json({ + error: "Invalid sessionId", + }) return } const transport = transports.get(req.query.sessionId) if (!transport) { console.log("No transport found") - res.status(500).json({ error: "No SSE connection established" }) + res.status(500).json({ + error: "No SSE connection established", + }) return } @@ -106,10 +110,14 @@ export async function main(appName?: string, portOption?: string) { console.error("Error handling message:", error) if (error instanceof Error) { console.error(error.stack) - res.status(500).json({ error: error.message }) + res.status(500).json({ + error: error.message, + }) } else { // For non-Error objects that were thrown - res.status(500).json({ error: String(error) }) + res.status(500).json({ + error: String(error), + }) } return } @@ -125,7 +133,7 @@ export async function main(appName?: string, portOption?: string) { app.post(`/:external_user_id/${appName}/messages`, async (req, res) => { console.log( `POST /:external_user_id/${appName}/messages`, - "[REDACTED]" // Redacted sessionId + "[REDACTED]", // Redacted sessionId ) await handlePostMessage(req, res) }) @@ -158,17 +166,17 @@ export async function main(appName?: string, portOption?: string) { console.log("- GET / - Health check") if (appName) { console.log( - `- GET /:external_user_id/${appName} - App-specific SSE connection endpoint` + `- GET /:external_user_id/${appName} - App-specific SSE connection endpoint`, ) console.log( - `- POST /:external_user_id/${appName}/messages - App-specific message handler` + `- POST /:external_user_id/${appName}/messages - App-specific message handler`, ) } else { console.log( - "- GET /:external_user_id/:app - App-specific SSE connection endpoint" + "- GET /:external_user_id/:app - App-specific SSE connection endpoint", ) console.log( - "- POST /:external_user_id/:app/messages - App-specific message handler" + "- POST /:external_user_id/:app/messages - App-specific message handler", ) } }) diff --git a/modelcontextprotocol/src/stdio.ts b/modelcontextprotocol/src/stdio.ts index 2fa7cc5088804..776cb0d565938 100644 --- a/modelcontextprotocol/src/stdio.ts +++ b/modelcontextprotocol/src/stdio.ts @@ -22,7 +22,7 @@ export async function main(appName: string, externalUserId?: string) { }) await server.connect(transport) console.error( - `pd-connect MCP Server running on stdio for app: ${appName}, external_user_id: ${userId}` + `pd-connect MCP Server running on stdio for app: ${appName}, external_user_id: ${userId}`, ) } diff --git a/modelcontextprotocol/tsconfig.json b/modelcontextprotocol/tsconfig.json index f7aa7e9ed8bf9..fccea27fdb8cc 100644 --- a/modelcontextprotocol/tsconfig.json +++ b/modelcontextprotocol/tsconfig.json @@ -13,4 +13,4 @@ }, "include": ["src/**/*", "lib/**/*"], "exclude": ["node_modules", "dist"] -} \ No newline at end of file +} From dd4fd64a0b2e379449c2345a3252e7047bf9f72b Mon Sep 17 00:00:00 2001 From: "Dylan J. Sather" Date: Thu, 27 Mar 2025 20:42:53 -0700 Subject: [PATCH 3/3] Small comments --- modelcontextprotocol/.dockerignore | 4 +--- modelcontextprotocol/lib/config.ts | 6 ++++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/modelcontextprotocol/.dockerignore b/modelcontextprotocol/.dockerignore index 840ec9d8e42ea..22d49bf4f8afa 100644 --- a/modelcontextprotocol/.dockerignore +++ b/modelcontextprotocol/.dockerignore @@ -2,7 +2,5 @@ node_modules dist *.md *.png -Dockerfile *.log -*.env - +*.env \ No newline at end of file diff --git a/modelcontextprotocol/lib/config.ts b/modelcontextprotocol/lib/config.ts index 4f1e934b5308f..1c1a210af8721 100644 --- a/modelcontextprotocol/lib/config.ts +++ b/modelcontextprotocol/lib/config.ts @@ -19,10 +19,12 @@ interface Config { export const config: Config = { // Default app to use if none is specified - defaultApp: "slack", + defaultApp: process.env.APP || "slack", // Port for the SSE server - serverPort: 3010, + serverPort: process.env.PORT + ? parseInt(process.env.PORT, 10) + : 3010, // Pipedream configuration pipedream: {