@submergedas/bitbucket-mcp 1.0.0

package/.env.example

@@ -0,0 +1,4 @@
+BITBUCKET_USERNAME=your_username
+BITBUCKET_API_TOKEN=your_api_token
+BITBUCKET_WORKSPACE=your_workspace
+BITBUCKET_REPO_SLUG=your_repo_slug

package/.envrc

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+if ! has nix_direnv_version || ! nix_direnv_version 3.1.0; then
+  source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/3.1.0/direnvrc" "sha256-yMJ2OVMzrFaDPn7q8nCBZFRYpL/f0RcHzhmw/i6btJM="
+fi
+
+export DEVENV_IN_DIRENV_SHELL=true
+
+watch_file flake.nix
+watch_file flake.lock
+if ! use flake . --no-pure-eval; then
+  echo "devenv could not be built. The devenv environment was not loaded. Make the necessary changes to devenv.nix and hit enter to try again." >&2
+fi

package/README.md

@@ -0,0 +1,60 @@
+# Bitbucket MCP Server
+
+An MCP server that provides access to Bitbucket repositories and pull requests.
+
+## Features
+
+### Resources
+- Read file content from repositories: `bitbucket://{workspace}/{repo_slug}/src/{commit}/{path}`
+
+### Tools
+- `list_repositories`: List repositories in a workspace.
+- `list_pull_requests`: List pull requests for a repository.
+- `get_pull_request`: Get details of a specific pull request.
+- `create_pull_request`: Create a new pull request.
+- `read_file`: Read content of a specific file.
+- `write_file`: Create or update a file's content.
+- `delete_file`: Delete a file.
+- `list_files`: List files in a directory.
+
+## Setup
+
+1.  **Install dependencies**:
+    ```bash
+    npm install
+    ```
+
+2.  **Build**:
+    ```bash
+    npm run build
+    ```
+    (You may need to add `"build": "tsc"` to `package.json` scripts if not present, checking project config...)
+    *Note: I ran `npx tsc` manually during setup.*
+
+3.  **Configure Environment Variables**:
+    Create a `.env` file based on `.env.example`:
+    ```env
+    BITBUCKET_USERNAME=your_username
+    BITBUCKET_API_TOKEN=your_api_token
+    ```
+
+    > **Important:** `BITBUCKET_API_TOKEN` is required. You can create one in Bitbucket Settings -> Personal Bitbucket Settings -> API tokens.
+
+## Usage
+
+To run the server with an MCP client (like Claude Desktop or similar):
+
+```json
+{
+  "mcpServers": {
+    "bitbucket": {
+      "command": "node",
+      "args": ["/path/to/bitbucket-MCP/dist/index.js"],
+      "env": {
+        "BITBUCKET_USERNAME": "your_username",
+        "BITBUCKET_API_TOKEN": "your_api_token"
+      }
+    }
+  }
+}
+```

package/dist/handlers/resources.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerResources = registerResources;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+function registerResources(server, bitbucket) {
+    server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+        // Bitbucket API doesn't have a direct "list all available resources" concept that maps 1:1 to MCP resources list
+        // efficiently without context. However, we can list repositories for the authenticated user/workspace 
+        // if we had the context of which workspace to list for. 
+        // For now, we'll return an empty list or maybe a static list if appropriate, 
+        // but the previous implementation didn't seem to list resources globally either, 
+        // it just defined patterns.
+        // Actually, looking at previous code:
+        // server.resource("repositories", new ResourceTemplate("bitbucket://{workspace}/repositories", ...))
+        // server.resource("file-content", new ResourceTemplate("bitbucket://{workspace}/{repo_slug}/src/{commit}/{path}", ...))
+        // The "list" capability in the new API is for listing concrete resources, not templates.
+        // If we want to expose templates, we might need a different approach or just not list them if they are dynamic.
+        // But RequestHandler for ListResourcesRequestSchema is expected.
+        return {
+            resources: [],
+        };
+    });
+    server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+        const uri = new URL(request.params.uri);
+        // Expected Patterns:
+        // bitbucket://{workspace}/repositories
+        // bitbucket://{workspace}/{repo_slug}/src/{commit}/{path}
+        const pathParts = uri.pathname.replace(/^\//, '').split('/');
+        const host = uri.host; // workspace
+        // Pattern 1: bitbucket://{workspace}/repositories
+        if (uri.protocol === "bitbucket:" && pathParts[0] === "repositories" && pathParts.length === 1) {
+            const workspace = host;
+            try {
+                const { data } = await bitbucket.repositories.list({
+                    workspace,
+                    pagelen: 50,
+                });
+                return {
+                    contents: [
+                        {
+                            uri: request.params.uri,
+                            mimeType: "application/json",
+                            text: JSON.stringify(data.values?.map((repo) => ({
+                                slug: repo.slug,
+                                name: repo.name,
+                                full_name: repo.full_name,
+                                description: repo.description,
+                                links: repo.links
+                            })), null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to list repositories: ${error.message}`);
+            }
+        }
+        // Pattern 2: bitbucket://{workspace}/{repo_slug}/src/{commit}/{path}
+        // uri.pathname starts with /. so pathParts[0] is repo_slug, [1] is 'src', [2] is commit, [3+] is path
+        if (uri.protocol === "bitbucket:" && pathParts.length >= 4 && pathParts[1] === "src") {
+            const workspace = host;
+            const repo_slug = pathParts[0];
+            const commit = pathParts[2];
+            const filePath = pathParts.slice(3).join('/');
+            try {
+                const { data } = await bitbucket.source.read({
+                    workspace,
+                    repo_slug,
+                    commit,
+                    path: filePath,
+                });
+                // Bitbucket might return text or binary. simpler to assume text for now or handle appropriately.
+                // If it's a directory listing, data will be a paginated response.
+                if (typeof data === "string") {
+                    return {
+                        contents: [
+                            {
+                                uri: request.params.uri,
+                                text: data,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    // It might be a directory or binary.
+                    // For simplicity, we'll serialize JSON if it's an object (directory listing)
+                    return {
+                        contents: [
+                            {
+                                uri: request.params.uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify(data, null, 2),
+                            },
+                        ],
+                    };
+                }
+            }
+            catch (error) {
+                throw new Error(`Failed to read file: ${error.message}`);
+            }
+        }
+        throw new Error(`Resource not found: ${request.params.uri}`);
+    });
+}

package/dist/handlers/tools.js

@@ -0,0 +1,478 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTools = registerTools;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const zod_1 = require("zod");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function registerTools(server, bitbucket, config) {
+    const { defaultWorkspace, defaultRepoSlug } = config;
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: "list_repositories",
+                    description: "List repositories in a workspace",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                    })),
+                },
+                {
+                    name: "list_pull_requests",
+                    description: "List pull requests for a repository",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        state: zod_1.z.enum(["OPEN", "MERGED", "DECLINED", "SUPERSEDED"]).optional().describe("Filter by PR state (default: OPEN)"),
+                    })),
+                },
+                {
+                    name: "get_pull_request",
+                    description: "Get details of a specific pull request",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        pull_request_id: zod_1.z.number().describe("The pull request ID"),
+                    })),
+                },
+                {
+                    name: "create_pull_request",
+                    description: "Create a new pull request",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        title: zod_1.z.string().optional().describe("Title of the pull request (default: generated from branches)"),
+                        source_branch: zod_1.z.string().describe("Name of the source branch"),
+                        destination_branch: zod_1.z.string().default("main").describe("Name of the destination branch"),
+                        description: zod_1.z.string().optional().describe("Description of the pull request"),
+                    })),
+                },
+                {
+                    name: "read_file",
+                    description: "Read content of a specific file",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        path: zod_1.z.string().describe("Path to the file"),
+                        commit: zod_1.z.string().optional().describe("Commit hash or branch name (defaults to main/master)"),
+                    })),
+                },
+                {
+                    name: "list_files",
+                    description: "List files in a directory",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        path: zod_1.z.string().describe("Path to the directory (empty for root)"),
+                        commit: zod_1.z.string().optional().describe("Commit hash or branch name"),
+                    })),
+                },
+                {
+                    name: "write_file",
+                    description: "Create or update a file's content",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        path: zod_1.z.string().describe("Path to the file"),
+                        content: zod_1.z.string().describe("Content of the file"),
+                        message: zod_1.z.string().describe("Commit message"),
+                        branch: zod_1.z.string().optional().describe("Branch to commit to (defaults to repository's default branch)"),
+                    })),
+                },
+                {
+                    name: "delete_file",
+                    description: "Delete a file",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        path: zod_1.z.string().describe("Path to the file to delete"),
+                        message: zod_1.z.string().describe("Commit message"),
+                        branch: zod_1.z.string().optional().describe("Branch to commit to"),
+                    })),
+                },
+                {
+                    name: "merge_pull_request",
+                    description: "Merge a pull request",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        pull_request_id: zod_1.z.number().describe("The pull request ID"),
+                        message: zod_1.z.string().optional().describe("Commit message"),
+                        close_source_branch: zod_1.z.boolean().optional().describe("Whether to close the source branch"),
+                        merge_strategy: zod_1.z.enum(["merge_commit", "squash", "fast_forward"]).optional().describe("Merge strategy"),
+                    })),
+                },
+                {
+                    name: "create_issue",
+                    description: "Create a new issue",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        title: zod_1.z.string().describe("Title of the issue"),
+                        description: zod_1.z.string().optional().describe("Description of the issue"),
+                        kind: zod_1.z.enum(["bug", "enhancement", "proposal", "task"]).optional().describe("Kind of issue"),
+                        priority: zod_1.z.enum(["trivial", "minor", "major", "critical", "blocker"]).optional().describe("Priority of issue"),
+                    })),
+                },
+                {
+                    name: "list_issues",
+                    description: "List issues in a repository",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        state: zod_1.z.enum(["new", "open", "resolved", "on hold", "invalid", "duplicate", "wontfix", "closed"]).optional().describe("Filter by issue state"),
+                    })),
+                },
+                {
+                    name: "get_issue",
+                    description: "Get details of a specific issue",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        issue_id: zod_1.z.string().describe("The issue ID"),
+                    })),
+                },
+                {
+                    name: "git_clone",
+                    description: "Clone a repository (requires git on the server path)",
+                    inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({
+                        workspace: zod_1.z.string().optional().describe(`The workspace slug/ID (default: ${defaultWorkspace || "required"})`),
+                        repo_slug: zod_1.z.string().optional().describe(`The repository slug (default: ${defaultRepoSlug || "required"})`),
+                        destination: zod_1.z.string().optional().describe("Local path to clone into (defaults to current directory + repo_slug)"),
+                    })),
+                },
+            ],
+        };
+    });
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        // Helper to get workspace/repo or throw
+        const getContext = (args) => {
+            const workspace = args?.workspace || defaultWorkspace;
+            const repo_slug = args?.repo_slug || defaultRepoSlug;
+            if (!workspace)
+                throw new Error("Workspace is required (no default set)");
+            if (!repo_slug)
+                throw new Error("Repository slug is required (no default set)");
+            return { workspace, repo_slug };
+        };
+        try {
+            if (name === "list_repositories") {
+                const workspace = args?.workspace || defaultWorkspace;
+                if (!workspace)
+                    throw new Error("Workspace is required");
+                const { data } = await bitbucket.repositories.list({
+                    workspace,
+                    pagelen: 50,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data.values?.map((repo) => ({
+                                slug: repo.slug,
+                                name: repo.name,
+                                full_name: repo.full_name,
+                                description: repo.description,
+                                links: repo.links
+                            })), null, 2),
+                        },
+                    ],
+                };
+            }
+            if (name === "list_pull_requests") {
+                const { workspace, repo_slug } = getContext(args);
+                const { state } = args;
+                const { data } = await bitbucket.pullrequests.list({
+                    workspace,
+                    repo_slug,
+                    state: state || "OPEN",
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data.values?.map((pr) => ({
+                                id: pr.id,
+                                title: pr.title,
+                                state: pr.state,
+                                author: pr.author?.display_name,
+                                created_on: pr.created_on,
+                                updated_on: pr.updated_on,
+                                links: pr.links
+                            })), null, 2),
+                        },
+                    ],
+                };
+            }
+            if (name === "get_pull_request") {
+                const { workspace, repo_slug } = getContext(args);
+                const { pull_request_id } = args;
+                const { data } = await bitbucket.pullrequests.get({
+                    workspace,
+                    repo_slug,
+                    pull_request_id,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data, null, 2),
+                        },
+                    ],
+                };
+            }
+            if (name === "create_pull_request") {
+                const { workspace, repo_slug } = getContext(args);
+                const { source_branch, destination_branch, description } = args;
+                let { title } = args;
+                if (!title) {
+                    title = `Merge ${source_branch} into ${destination_branch}`;
+                }
+                const { data } = await bitbucket.pullrequests.create({
+                    workspace,
+                    repo_slug,
+                    _body: {
+                        title,
+                        description,
+                        source: {
+                            branch: {
+                                name: source_branch
+                            }
+                        },
+                        destination: {
+                            branch: {
+                                name: destination_branch
+                            }
+                        }
+                    }
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data, null, 2),
+                        },
+                    ],
+                };
+            }
+            if (name === "read_file") {
+                const { workspace, repo_slug } = getContext(args);
+                const { path, commit } = args;
+                const { data } = await bitbucket.source.read({
+                    workspace,
+                    repo_slug,
+                    path,
+                    commit,
+                });
+                if (typeof data === "string") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: data,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(data, null, 2),
+                            },
+                        ],
+                    };
+                }
+            }
+            if (name === "list_files") {
+                const { workspace, repo_slug } = getContext(args);
+                const { path, commit } = args;
+                const { data } = await bitbucket.source.read({
+                    workspace,
+                    repo_slug,
+                    path: path || "",
+                    commit,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data, null, 2),
+                        },
+                    ],
+                };
+            }
+            if (name === "write_file") {
+                const { workspace, repo_slug } = getContext(args);
+                const { path, content, message, branch } = args;
+                const body = {};
+                body[path] = content;
+                const { data } = await bitbucket.repositories.createSrcFileCommit({
+                    workspace,
+                    repo_slug,
+                    message,
+                    branch,
+                    _body: body,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "File written successfully",
+                        },
+                    ],
+                };
+            }
+            if (name === "delete_file") {
+                const { workspace, repo_slug } = getContext(args);
+                const { path, message, branch } = args;
+                const { data } = await bitbucket.repositories.createSrcFileCommit({
+                    workspace,
+                    repo_slug,
+                    message,
+                    branch,
+                    files: path,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "File deleted successfully",
+                        },
+                    ],
+                };
+            }
+            if (name === "merge_pull_request") {
+                const { workspace, repo_slug } = getContext(args);
+                const { pull_request_id, message, close_source_branch, merge_strategy } = args;
+                const { data } = await bitbucket.repositories.mergePullRequest({
+                    workspace,
+                    repo_slug,
+                    pull_request_id,
+                    _body: {
+                        message,
+                        close_source_branch,
+                        merge_strategy,
+                    },
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data, null, 2),
+                        },
+                    ],
+                };
+            }
+            if (name === "create_issue") {
+                const { workspace, repo_slug } = getContext(args);
+                const { title, description, kind, priority } = args;
+                const { data } = await bitbucket.issue_tracker.create({
+                    workspace,
+                    repo_slug,
+                    _body: {
+                        title,
+                        content: {
+                            raw: description || "",
+                        },
+                        kind,
+                        priority,
+                    },
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data, null, 2),
+                        },
+                    ],
+                };
+            }
+            if (name === "list_issues") {
+                const { workspace, repo_slug } = getContext(args);
+                const { state } = args;
+                const q = state ? `state="${state}"` : undefined;
+                const { data } = await bitbucket.issue_tracker.list({
+                    workspace,
+                    repo_slug,
+                    q,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data.values?.map((issue) => ({
+                                id: issue.id,
+                                title: issue.title,
+                                state: issue.state,
+                                kind: issue.kind,
+                                priority: issue.priority,
+                                created_on: issue.created_on,
+                                updated_on: issue.updated_on,
+                                links: issue.links
+                            })), null, 2),
+                        },
+                    ],
+                };
+            }
+            if (name === "git_clone") {
+                const { workspace, repo_slug } = getContext(args);
+                const { destination } = args;
+                // Note: bitbucket.proxy is not a public property, so we are accessing private credentials here effectively.
+                // However, the `bitbucket` instance doesn't easily expose the raw credentials.
+                // We will fallback to process.env since that's how we initialized it.
+                const username = process.env.BITBUCKET_USERNAME;
+                const appPassword = process.env.BITBUCKET_APP_PASSWORD;
+                const apiToken = process.env.BITBUCKET_API_TOKEN;
+                const password = apiToken || appPassword;
+                if (!username || !password) {
+                    throw new Error("Missing BITBUCKET_USERNAME or BITBUCKET_API_TOKEN/APP_PASSWORD in environment variables");
+                }
+                const authUrl = `https://${username}:${password}@bitbucket.org/${workspace}/${repo_slug}.git`;
+                const destPath = destination || repo_slug; // Default to repo_slug if no destination provided
+                await execAsync(`git clone ${authUrl} ${destPath}`);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Successfully cloned ${workspace}/${repo_slug} into ${destPath}`,
+                        },
+                    ],
+                };
+            }
+            if (name === "get_issue") {
+                const { workspace, repo_slug } = getContext(args);
+                const { issue_id } = args;
+                const { data } = await bitbucket.issue_tracker.get({
+                    workspace,
+                    repo_slug,
+                    issue_id,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data, null, 2),
+                        },
+                    ],
+                };
+            }
+            throw new Error(`Tool not found: ${name}`);
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}