@samik081/mcp-komodo 0.1.0

package/dist/tools/deployments.js

@@ -0,0 +1,282 @@
+/**
+ * Deployment domain tools: list, get, log, deploy, lifecycle, destroy.
+ *
+ * Registers 6 MCP tools for Komodo Deployment resources.
+ * A Deployment is a single Docker container managed by Komodo,
+ * deployed to a specific server.
+ */
+import { z } from "zod";
+import { Types } from "komodo_client";
+import { handleKomodoError } from "../core/errors.js";
+import { formatDeploymentList, formatDeploymentDetail, formatLog, formatUpdateCreated, } from "../core/formatters.js";
+import { registerTool } from "../core/tools.js";
+export function registerDeploymentTools(server, client, config) {
+    // -------------------------------------------------------------------------
+    // komodo_list_deployments
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_list_deployments",
+        description: "List all Komodo Deployments. A Deployment is a single Docker " +
+            "container managed by Komodo, deployed to a specific server. " +
+            "Returns name, state, image, and server for each deployment.",
+        accessTier: "read-only",
+        category: "deployments",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+        inputSchema: {
+            tag: z.string().optional().describe("Filter deployments by tag name"),
+        },
+        handler: async (args) => {
+            const tag = args.tag;
+            try {
+                const deployments = await client.read("ListDeployments", {
+                    query: tag ? { tags: [tag] } : undefined,
+                });
+                return {
+                    content: [
+                        { type: "text", text: formatDeploymentList(deployments) },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError("listing deployments", error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_get_deployment
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_get_deployment",
+        description: "Get detailed information about a specific Komodo Deployment by " +
+            "name or ID. A Deployment is a single Docker container managed by " +
+            "Komodo. Returns configuration, image, state, container status, " +
+            "and current action state.",
+        accessTier: "read-only",
+        category: "deployments",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+        inputSchema: {
+            deployment: z.string().describe("Deployment name or ID"),
+        },
+        handler: async (args) => {
+            const deployment = args.deployment;
+            try {
+                const [deploymentData, actionState] = await Promise.all([
+                    client.read("GetDeployment", { deployment }),
+                    client.read("GetDeploymentActionState", { deployment }),
+                ]);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatDeploymentDetail(deploymentData, actionState),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`getting deployment '${deployment}'`, error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_get_deployment_log
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_get_deployment_log",
+        description: "Get logs from a Komodo Deployment's Docker container. Optionally " +
+            "search for specific terms in the log output. A Deployment is a " +
+            "single Docker container managed by Komodo. Returns the most " +
+            "recent log lines from the container.",
+        accessTier: "read-only",
+        category: "deployments",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+        inputSchema: {
+            deployment: z.string().describe("Deployment name or ID"),
+            tail: z
+                .number()
+                .min(1)
+                .max(5000)
+                .optional()
+                .describe("Number of log lines to return (default: 50, max: 5000)"),
+            search_terms: z
+                .array(z.string())
+                .optional()
+                .describe("Search for lines matching these terms"),
+            search_combinator: z
+                .enum(["And", "Or"])
+                .optional()
+                .describe("How to combine search terms: 'And' = all terms must match, " +
+                "'Or' = any term matches (default: 'Or')"),
+        },
+        handler: async (args) => {
+            const deployment = args.deployment;
+            const tail = args.tail;
+            const search_terms = args.search_terms;
+            const search_combinator = args.search_combinator;
+            try {
+                let log;
+                if (search_terms && search_terms.length > 0) {
+                    log = await client.read("SearchDeploymentLog", {
+                        deployment,
+                        terms: search_terms,
+                        combinator: search_combinator || Types.SearchCombinator.Or,
+                    });
+                }
+                else {
+                    log = await client.read("GetDeploymentLog", {
+                        deployment,
+                        tail: tail || 50,
+                    });
+                }
+                return {
+                    content: [{ type: "text", text: formatLog(log) }],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`getting logs for deployment '${deployment}'`, error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_deploy_deployment
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_deploy_deployment",
+        description: "\u26a0\ufe0f DEPLOY a Komodo Deployment. This stops the current container " +
+            "and starts a new one with the latest image and configuration. The " +
+            "service will be briefly unavailable during redeployment. A " +
+            "Deployment is a single Docker container managed by Komodo.",
+        accessTier: "read-execute",
+        category: "deployments",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+        },
+        inputSchema: {
+            deployment: z.string().describe("Deployment name or ID"),
+        },
+        handler: async (args) => {
+            const deployment = args.deployment;
+            try {
+                const update = await client.execute("Deploy", { deployment });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatUpdateCreated(update, `Deploying deployment '${deployment}'`),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`deploying deployment '${deployment}'`, error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_deployment_lifecycle
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_deployment_lifecycle",
+        description: "\u26a0\ufe0f LIFECYCLE: Control a Komodo Deployment's container lifecycle. " +
+            "A Deployment is a single Docker container managed by Komodo. " +
+            "Actions: 'start' brings container up, 'stop' brings it down " +
+            "gracefully, 'restart' stops then starts, 'pause' freezes without " +
+            "stopping (uses Docker pause), 'unpause' resumes from pause. " +
+            "Stop/restart cause downtime.",
+        accessTier: "read-execute",
+        category: "deployments",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+        },
+        inputSchema: {
+            deployment: z.string().describe("Deployment name or ID"),
+            action: z
+                .enum(["start", "stop", "restart", "pause", "unpause"])
+                .describe("Lifecycle action to perform"),
+        },
+        handler: async (args) => {
+            const deployment = args.deployment;
+            const action = args.action;
+            try {
+                const operationMap = {
+                    start: "StartDeployment",
+                    stop: "StopDeployment",
+                    restart: "RestartDeployment",
+                    pause: "PauseDeployment",
+                    unpause: "UnpauseDeployment",
+                };
+                const update = await client.execute(operationMap[action], {
+                    deployment,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatUpdateCreated(update, `${action} deployment '${deployment}'`),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`${action} deployment '${deployment}'`, error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_destroy_deployment
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_destroy_deployment",
+        description: "\ud83d\udd34 DESTROY a Komodo Deployment permanently. This stops the " +
+            "container and removes the deployment configuration from Komodo. " +
+            "THIS CANNOT BE UNDONE. The container and its data will be " +
+            "deleted. Only use this when you're certain the deployment should " +
+            "be permanently removed. A Deployment is a single Docker container " +
+            "managed by Komodo.",
+        accessTier: "read-execute",
+        category: "deployments",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+        },
+        inputSchema: {
+            deployment: z.string().describe("Deployment name or ID"),
+        },
+        handler: async (args) => {
+            const deployment = args.deployment;
+            try {
+                const update = await client.execute("DestroyDeployment", {
+                    deployment,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatUpdateCreated(update, `Destroying deployment '${deployment}' - this is permanent`),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`destroying deployment '${deployment}'`, error);
+            }
+        },
+    });
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tool registration barrel file.
+ *
+ * Imports all domain tool modules and exports a single
+ * registerAllTools() function that wires them into the MCP server.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { createClient } from "../core/client.js";
+import type { AppConfig } from "../core/config.js";
+export declare function registerAllTools(server: McpServer, client: ReturnType<typeof createClient>, config: AppConfig): void;

package/dist/tools/index.js

@@ -0,0 +1,32 @@
+/**
+ * Tool registration barrel file.
+ *
+ * Imports all domain tool modules and exports a single
+ * registerAllTools() function that wires them into the MCP server.
+ */
+import { registerServerTools } from "./servers.js";
+import { registerStackTools } from "./stacks.js";
+import { registerDeploymentTools } from "./deployments.js";
+import { registerContainerTools } from "./containers.js";
+import { registerBuildTools } from "./builds.js";
+import { registerRepoTools } from "./repos.js";
+import { registerProcedureTools } from "./procedures.js";
+import { registerActionTools } from "./actions.js";
+import { registerBuilderTools } from "./builders.js";
+import { registerAlerterTools } from "./alerters.js";
+import { registerResourceSyncTools } from "./resource-syncs.js";
+import { registerWriteTools } from "./write.js";
+export function registerAllTools(server, client, config) {
+    registerServerTools(server, client, config);
+    registerStackTools(server, client, config);
+    registerDeploymentTools(server, client, config);
+    registerContainerTools(server, client, config);
+    registerBuildTools(server, client, config);
+    registerRepoTools(server, client, config);
+    registerProcedureTools(server, client, config);
+    registerActionTools(server, client, config);
+    registerBuilderTools(server, client, config);
+    registerAlerterTools(server, client, config);
+    registerResourceSyncTools(server, client, config);
+    registerWriteTools(server, client, config);
+}

package/dist/tools/procedures.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Procedure domain tools: list, get detail, run.
+ *
+ * Registers 3 MCP tools for Komodo Procedure resources.
+ * A Procedure is an orchestrated sequence of parallel stages that run
+ * other Komodo operations (deploy, build, pull, etc.).
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { createClient } from "../core/client.js";
+import type { AppConfig } from "../core/config.js";
+type KomodoClient = ReturnType<typeof createClient>;
+export declare function registerProcedureTools(server: McpServer, client: KomodoClient, config: AppConfig): void;
+export {};

package/dist/tools/procedures.js

@@ -0,0 +1,130 @@
+/**
+ * Procedure domain tools: list, get detail, run.
+ *
+ * Registers 3 MCP tools for Komodo Procedure resources.
+ * A Procedure is an orchestrated sequence of parallel stages that run
+ * other Komodo operations (deploy, build, pull, etc.).
+ */
+import { z } from "zod";
+import { handleKomodoError } from "../core/errors.js";
+import { formatProcedureList, formatProcedureDetail, formatUpdateCreated, } from "../core/formatters.js";
+import { registerTool } from "../core/tools.js";
+export function registerProcedureTools(server, client, config) {
+    // -------------------------------------------------------------------------
+    // komodo_list_procedures
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_list_procedures",
+        description: "List all Komodo Procedures. A Procedure is an orchestrated " +
+            "sequence of parallel stages that run other Komodo operations " +
+            "(deploy, build, pull, etc.). Returns name and state for each " +
+            "procedure.",
+        accessTier: "read-only",
+        category: "procedures",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+        inputSchema: {
+            tag: z
+                .string()
+                .optional()
+                .describe("Filter procedures by tag name"),
+        },
+        handler: async (args) => {
+            const tag = args.tag;
+            try {
+                const procedures = await client.read("ListProcedures", {
+                    query: tag ? { tags: [tag] } : undefined,
+                });
+                return {
+                    content: [
+                        { type: "text", text: formatProcedureList(procedures) },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError("listing procedures", error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_get_procedure
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_get_procedure",
+        description: "Get detailed information about a specific Komodo Procedure by " +
+            "name or ID. A Procedure is an orchestrated sequence of stages. " +
+            "Returns stages with their operations and current action state.",
+        accessTier: "read-only",
+        category: "procedures",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+        inputSchema: {
+            procedure: z.string().describe("Procedure name or ID"),
+        },
+        handler: async (args) => {
+            const procedure = args.procedure;
+            try {
+                const [procedureData, actionState] = await Promise.all([
+                    client.read("GetProcedure", { procedure }),
+                    client.read("GetProcedureActionState", { procedure }),
+                ]);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatProcedureDetail(procedureData, actionState),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`getting procedure '${procedure}'`, error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_run_procedure
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_run_procedure",
+        description: "\u26a0\ufe0f RUN a Komodo Procedure. This executes all stages in sequence, " +
+            "where each stage can run multiple operations in parallel. A " +
+            "Procedure may deploy stacks, run builds, pull repos, and perform " +
+            "other Komodo operations. Procedures can take several minutes " +
+            "depending on their stages. A Procedure is an orchestrated sequence " +
+            "of parallel stages.",
+        accessTier: "read-execute",
+        category: "procedures",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+        },
+        inputSchema: {
+            procedure: z.string().describe("Procedure name or ID"),
+        },
+        handler: async (args) => {
+            const procedure = args.procedure;
+            try {
+                const update = await client.execute("RunProcedure", { procedure });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatUpdateCreated(update, `Running procedure '${procedure}'`),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`running procedure '${procedure}'`, error);
+            }
+        },
+    });
+}

package/dist/tools/repos.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Repo domain tools: list, get detail, clone/pull.
+ *
+ * Registers 3 MCP tools for Komodo Repo resources.
+ * A Repo is a Git repository cloned to a server, optionally built
+ * using a Builder.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { createClient } from "../core/client.js";
+import type { AppConfig } from "../core/config.js";
+type KomodoClient = ReturnType<typeof createClient>;
+export declare function registerRepoTools(server: McpServer, client: KomodoClient, config: AppConfig): void;
+export {};

package/dist/tools/repos.js

@@ -0,0 +1,132 @@
+/**
+ * Repo domain tools: list, get detail, clone/pull.
+ *
+ * Registers 3 MCP tools for Komodo Repo resources.
+ * A Repo is a Git repository cloned to a server, optionally built
+ * using a Builder.
+ */
+import { z } from "zod";
+import { handleKomodoError } from "../core/errors.js";
+import { formatRepoList, formatRepoDetail, formatUpdateCreated, } from "../core/formatters.js";
+import { registerTool } from "../core/tools.js";
+export function registerRepoTools(server, client, config) {
+    // -------------------------------------------------------------------------
+    // komodo_list_repos
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_list_repos",
+        description: "List all Komodo Repos. A Repo is a Git repository cloned to a " +
+            "server, optionally built using a Builder. Returns name, repo URL, " +
+            "server, and state for each repo.",
+        accessTier: "read-only",
+        category: "repos",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+        inputSchema: {
+            tag: z.string().optional().describe("Filter repos by tag name"),
+        },
+        handler: async (args) => {
+            const tag = args.tag;
+            try {
+                const repos = await client.read("ListRepos", {
+                    query: tag ? { tags: [tag] } : undefined,
+                });
+                return {
+                    content: [{ type: "text", text: formatRepoList(repos) }],
+                };
+            }
+            catch (error) {
+                return handleKomodoError("listing repos", error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_get_repo
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_get_repo",
+        description: "Get detailed information about a specific Komodo Repo by name " +
+            "or ID. A Repo is a Git repository cloned to a server. Returns " +
+            "clone URL, branch, server, on_clone/on_pull commands, and " +
+            "current action state.",
+        accessTier: "read-only",
+        category: "repos",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+        inputSchema: {
+            repo: z.string().describe("Repo name or ID"),
+        },
+        handler: async (args) => {
+            const repo = args.repo;
+            try {
+                const [repoData, actionState] = await Promise.all([
+                    client.read("GetRepo", { repo }),
+                    client.read("GetRepoActionState", { repo }),
+                ]);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatRepoDetail(repoData, actionState),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`getting repo '${repo}'`, error);
+            }
+        },
+    });
+    // -------------------------------------------------------------------------
+    // komodo_repo_clone_pull
+    // -------------------------------------------------------------------------
+    registerTool(server, config, {
+        name: "komodo_repo_clone_pull",
+        description: "\u26a0\ufe0f CLONE or PULL a Komodo Repo on its target server. 'clone' " +
+            "performs initial git clone (or pulls if already cloned). 'pull' " +
+            "performs git pull to get latest changes. Both may trigger " +
+            "on_clone/on_pull commands configured on the repo. A Repo is a " +
+            "Git repository cloned to a server.",
+        accessTier: "read-execute",
+        category: "repos",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+        },
+        inputSchema: {
+            repo: z.string().describe("Repo name or ID"),
+            action: z
+                .enum(["clone", "pull"])
+                .describe("Whether to clone or pull the repo"),
+        },
+        handler: async (args) => {
+            const repo = args.repo;
+            const action = args.action;
+            try {
+                const operationMap = {
+                    clone: "CloneRepo",
+                    pull: "PullRepo",
+                };
+                const update = await client.execute(operationMap[action], { repo });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatUpdateCreated(update, `${action} repo '${repo}'`),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return handleKomodoError(`${action} repo '${repo}'`, error);
+            }
+        },
+    });
+}

package/dist/tools/resource-syncs.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ResourceSync domain tools: list, get detail, trigger sync.
+ *
+ * Registers 3 MCP tools for Komodo ResourceSync resources.
+ * A ResourceSync is a GitOps sync that manages Komodo resources from
+ * TOML configuration files in a Git repository.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { createClient } from "../core/client.js";
+import type { AppConfig } from "../core/config.js";
+type KomodoClient = ReturnType<typeof createClient>;
+export declare function registerResourceSyncTools(server: McpServer, client: KomodoClient, config: AppConfig): void;
+export {};