bump-cli 2.9.11 → 2.10.0

package/dist/core/schemas/flower-schemas/index.d.ts

@@ -0,0 +1,7 @@
+import type { JSONSchema7 } from 'json-schema';
+declare const _default: {
+    schemas: {
+        '0.1': JSONSchema7;
+    };
+};
+export default _default;

package/dist/core/schemas/flower-schemas/index.js

@@ -0,0 +1,6 @@
+import schemaV01 from './v0.1/schema.json' with { type: 'json' };
+export default {
+    schemas: {
+        '0.1': schemaV01,
+    },
+};

package/dist/core/schemas/flower-schemas/v0.1/schema.json

@@ -0,0 +1,267 @@
+{
+    "title": "Flower 0.1 schema",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "required": [
+        "flower",
+        "id",
+        "flows"
+    ],
+    "additionalProperties": false,
+    "patternProperties": {
+        "^x-[\\w\\d\\.\\-\\_]+$": {
+            "$ref": "#/definitions/specificationExtension"
+        }
+    },
+    "properties": {
+        "flower": {
+            "type": [
+                "string"
+            ],
+            "enum": [
+                "0.1"
+            ],
+            "description": "The Flower specification version of this document."
+        },
+        "id": {
+            "type": "string",
+            "description": "A unique id representing the workflow set."
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "flows": {
+            "type": "array",
+            "items": {
+                "$ref": "#/definitions/flow"
+            }
+        }
+    },
+    "definitions": {
+        "flow": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "inputs": {
+                    "$ref": "#/definitions/schema"
+                },
+                "outputs": {
+                    "$ref": "#/definitions/expressionMap"
+                },
+                "steps": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/step"
+                    }
+                }
+            },
+            "required": [
+                "id",
+                "steps"
+            ]
+        },
+        "step": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "string"
+                },
+                "outputs": {
+                    "$ref": "#/definitions/expressionMap"
+                },
+                "request": {
+                    "type": "object",
+                    "properties": {
+                        "method": {
+                            "type": "string"
+                        },
+                        "url": {
+                            "type": "string"
+                        },
+                        "headers": {
+                            "$ref": "#/definitions/expressionMap"
+                        },
+                        "query": {
+                            "$ref": "#/definitions/expressionMap"
+                        },
+                        "body": {
+                            "$ref": "#/definitions/expressionMap"
+                        }
+                    }
+                },
+                "actions": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "$ref": "#/definitions/next"
+                            },
+                            {
+                                "$ref": "#/definitions/retry"
+                            },
+                            {
+                                "$ref": "#/definitions/goto"
+                            },
+                            {
+                                "$ref": "#/definitions/end"
+                            }
+                        ]
+                    }
+                }
+            },
+            "required": [
+                "id",
+                "request"
+            ]
+        },
+        "action": {
+            "type": "object",
+            "required": [
+                "do"
+            ],
+            "properties": {
+                "id": {
+                    "type": "string"
+                },
+                "when": {
+                    "type": "string",
+                    "description": "A runtime expression conditioning this action"
+                },
+                "do": {
+                    "type": "string"
+                }
+            },
+            "discriminator": {
+                "propertyName": "do",
+                "mapping": {
+                    "next": "#/definitions/next",
+                    "retry": "#/definitions/retry",
+                    "goto": "#/definitions/goto",
+                    "end": "#/definitions/end"
+                }
+            }
+        },
+        "next": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/action"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "do": {
+                            "type": "string",
+                            "const": "next"
+                        }
+                    }
+                }
+            ]
+        },
+        "retry": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/action"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "do": {
+                            "type": "string",
+                            "const": "retry"
+                        },
+                        "wait": {
+                            "type": "integer",
+                            "description": "Number of seconds to wait",
+                            "default": 5
+                        },
+                        "max_retry": {
+                            "type": "integer",
+                            "description": "Maximum number of subsequent retries to execute",
+                            "default": 5
+                        }
+                    }
+                }
+            ]
+        },
+        "goto": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/action"
+                },
+                {
+                    "type": "object",
+                    "required": [
+                        "step"
+                    ],
+                    "properties": {
+                        "do": {
+                            "type": "string",
+                            "const": "goto"
+                        },
+                        "step": {
+                            "type": "string",
+                            "description": "The target step ID to jump to"
+                        }
+                    }
+                }
+            ]
+        },
+        "end": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/action"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "do": {
+                            "type": "string",
+                            "const": "end"
+                        }
+                    }
+                }
+            ]
+        },
+        "expressionMap": {
+            "type": "object",
+            "description": "A map of names to runtime expressions.",
+            "additionalProperties": {
+                "type": "string",
+                "description": "A runtime expression."
+            }
+        },
+        "schema": {
+            "allOf": [
+                {
+                    "$ref": "http://json-schema.org/draft-07/schema#"
+                },
+                {
+                    "type": "object",
+                    "patternProperties": {
+                        "^x-[\\w\\d\\.\\-\\_]+$": {
+                            "$ref": "#/definitions/specificationExtension"
+                        }
+                    }
+                }
+            ]
+        },
+        "specificationExtension": {
+            "oneOf": [
+                {
+                    "type": "object",
+                    "description": "Any property starting with x- is valid.",
+                    "additionalProperties": true
+                },
+                {}
+            ]
+        }
+    }
+}

package/dist/core/workflow-deploy.d.ts

@@ -0,0 +1,10 @@
+import { BumpApi } from '../api/index.js';
+import { WorkflowVersionRequest, WorkflowVersionResponse } from '../api/models.js';
+import { API } from '../definition.js';
+export declare class WorkflowDeploy {
+    private _bump;
+    constructor(bumpClient: BumpApi);
+    protected createWorkflowVersion(mcpServer: string, request: WorkflowVersionRequest, token: string): Promise<WorkflowVersionResponse | undefined>;
+    d(formatter: any, ...args: any[]): void;
+    run(workflowDefinition: API, mcpServer: string, token: string): Promise<WorkflowVersionResponse | undefined>;
+}

package/dist/core/workflow-deploy.js

@@ -0,0 +1,37 @@
+import debug from 'debug';
+export class WorkflowDeploy {
+    _bump;
+    constructor(bumpClient) {
+        this._bump = bumpClient;
+    }
+    async createWorkflowVersion(mcpServer, request, token) {
+        const response = await this._bump.postMCPServerDeploy(mcpServer, request, token);
+        let version;
+        switch (response.status) {
+            case 204: {
+                break; // MCP server workflow document already exists
+            }
+            case 201: {
+                version = response.data;
+                break;
+            }
+            default: {
+                this.d(`API status response was ${response.status}. Expected 201 or 204.`);
+                throw new Error('Unexpected server response. Please contact support at https://bump.sh if this error persists');
+            }
+        }
+        return version;
+    }
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    d(formatter, ...args) {
+        return debug(`bump-cli:core:deploy`)(formatter, ...args);
+    }
+    async run(workflowDefinition, mcpServer, token) {
+        let version;
+        const [definition, references] = await workflowDefinition.extractDefinition();
+        const request = { definition, references };
+        // eslint-disable-next-line prefer-const
+        version = await this.createWorkflowVersion(mcpServer, request, token);
+        return version;
+    }
+}

package/dist/definition.d.ts

@@ -1,8 +1,10 @@
 import { JSONSchema4, JSONSchema4Array, JSONSchema4Object, JSONSchema6, JSONSchema6Object, JSONSchema7 } from 'json-schema';
-type SpecSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
+type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 declare class SupportedFormat {
-    static readonly asyncapi: Record<string, SpecSchema>;
-    static readonly openapi: Record<string, SpecSchema>;
+    static readonly arazzo: Record<string, JSONSchema>;
+    static readonly asyncapi: Record<string, JSONSchema>;
+    static readonly flower: Record<string, JSONSchema>;
+    static readonly openapi: Record<string, JSONSchema>;
 }
 declare class API {
     readonly definition: APIDefinition;
@@ -10,32 +12,40 @@ declare class API {
     overlayedDefinition: APIDefinition | undefined;
     readonly rawDefinition: string;
     readonly references: APIReference[];
-    readonly spec?: SpecSchema;
-    readonly specName: string;
-    readonly version: string;
-    constructor(location: string, values: SpecSchema);
+    readonly specName?: string;
+    readonly version?: string;
+    constructor(location: string, data: Record<string, JSONSchemaWithRaw>);
+    static isArazzo(definition: JSONSchema4Object | JSONSchema6Object): definition is Arazzo;
     static isAsyncAPI(definition: JSONSchema4Object | JSONSchema6Object): definition is AsyncAPI;
+    static isFlower(definition: JSONSchema4Object | JSONSchema6Object): definition is Flower;
     static isOpenAPI(definition: JSONSchema4Object | JSONSchema6Object): definition is OpenAPI;
     static isOpenAPIOverlay(definition: JSONSchema4Object | JSONSchema6Object): definition is OpenAPIOverlay;
+    static isSupportedFormat(definition: JSONSchema4Object | JSONSchema6Object): definition is APIDefinition;
     static load(path: string): Promise<API>;
     applyOverlay(overlayPath: string): Promise<void>;
     extractDefinition(outputPath?: string, overlays?: string[] | undefined): Promise<[string, APIReference[]]>;
-    getSpec(definition: APIDefinition): SpecSchema;
-    getSpecName(definition: APIDefinition): string;
-    getVersion(definition: APIDefinition): string;
+    getSpec(definition: APIDefinition): JSONSchema | undefined;
+    getSpecName(definition: APIDefinition): string | undefined;
+    getVersion(definition: APIDefinition): string | undefined;
     guessFormat(output?: string): string;
     isMainRefPath(path: string): boolean;
-    resolveContent(values: SpecSchema): [string, APIDefinition];
-    resolveRelativeLocation(absPath: string): string;
     serializeDefinition(outputPath?: string): string;
     versionWithoutPatch(): string;
+    private _resolveArazzoSourceDescriptions;
+    private _resolveContentFrom;
+    private _resolveRelativeLocation;
     private url;
 }
+type JSONSchemaWithRaw = {
+    readonly parsed?: JSONSchema4 | JSONSchema4Object | JSONSchema6 | JSONSchema6Object | string;
+    readonly raw?: string;
+};
 type APIReference = {
     content: string;
     location: string;
+    name?: string;
 };
-type APIDefinition = AsyncAPI | OpenAPI | OpenAPIOverlay;
+type APIDefinition = Arazzo | AsyncAPI | Flower | OpenAPI | OpenAPIOverlay;
 type InfoObject = {
     readonly description?: string;
     readonly title: string;
@@ -55,4 +65,11 @@ type AsyncAPI = {
     readonly asyncapi: string;
     readonly info: InfoObject;
 } & JSONSchema4Object;
-export { API, APIDefinition, OpenAPIOverlay, SupportedFormat };
+type Flower = {
+    readonly flower: string;
+} & JSONSchema4Object;
+type Arazzo = {
+    readonly arazzo: string;
+    readonly info: InfoObject;
+} & JSONSchema4Object;
+export { API, APIDefinition, OpenAPI, OpenAPIOverlay, SupportedFormat };