@hanzo/platform-mcp 1.4.0

package/build/mcp/tools/mysql/mysqlChangeStatus.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlChangeStatus = createTool({
+    name: "mysql-changeStatus",
+    description: "Changes the status of a MySQL database in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to update."),
+        applicationStatus: z
+            .enum(["idle", "running", "done", "error"])
+            .describe("The new status for the MySQL database."),
+    }),
+    annotations: {
+        title: "Change MySQL Database Status",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.changeStatus", input);
+        return ResponseFormatter.success(`MySQL database status changed to "${input.applicationStatus}" successfully`, response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlCreate.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlCreate = createTool({
+    name: "mysql-create",
+    description: "Creates a new MySQL database in Platform.",
+    schema: z.object({
+        name: z.string().min(1).describe("The name of the MySQL database."),
+        appName: z.string().min(1).describe("The app name for the MySQL database."),
+        databaseName: z
+            .string()
+            .min(1)
+            .describe("The name of the database to create."),
+        databaseUser: z
+            .string()
+            .min(1)
+            .describe("The username for database access."),
+        databasePassword: z.string().describe("The password for database access."),
+        databaseRootPassword: z.string().describe("The root password for MySQL."),
+        dockerImage: z
+            .string()
+            .optional()
+            .default("mysql:8")
+            .describe("Docker image to use for MySQL."),
+        projectId: z
+            .string()
+            .describe("The ID of the project where the database will be created."),
+        description: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("An optional description for the database."),
+        serverId: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("The ID of the server where the database will be deployed."),
+    }),
+    annotations: {
+        title: "Create MySQL Database",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.create", input);
+        return ResponseFormatter.success(`MySQL database "${input.name}" created successfully`, response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlDeploy.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlDeploy = createTool({
+    name: "mysql-deploy",
+    description: "Deploys a MySQL database in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to deploy."),
+    }),
+    annotations: {
+        title: "Deploy MySQL Database",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.deploy", input);
+        return ResponseFormatter.success("MySQL database deployed successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlMove.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlMove = createTool({
+    name: "mysql-move",
+    description: "Moves a MySQL database to a different project in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to move."),
+        targetProjectId: z
+            .string()
+            .describe("The ID of the target project to move the database to."),
+    }),
+    annotations: {
+        title: "Move MySQL Database",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.move", input);
+        return ResponseFormatter.success("MySQL database moved successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlOne.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlOne = createTool({
+    name: "mysql-one",
+    description: "Gets a specific MySQL database by its ID in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to retrieve."),
+    }),
+    annotations: {
+        title: "Get MySQL Database",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.get("/mysql.one", {
+            params: { mysqlId: input.mysqlId },
+        });
+        return ResponseFormatter.success("MySQL database retrieved successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlRebuild.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlRebuild = createTool({
+    name: "mysql-rebuild",
+    description: "Rebuilds a MySQL database in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to rebuild."),
+    }),
+    annotations: {
+        title: "Rebuild MySQL Database",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.rebuild", input);
+        return ResponseFormatter.success("MySQL database rebuild initiated successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlReload.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlReload = createTool({
+    name: "mysql-reload",
+    description: "Reloads a MySQL database configuration in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to reload."),
+        appName: z.string().min(1).describe("The app name for the MySQL database."),
+    }),
+    annotations: {
+        title: "Reload MySQL Database",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.reload", input);
+        return ResponseFormatter.success("MySQL database reloaded successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlRemove.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlRemove = createTool({
+    name: "mysql-remove",
+    description: "Removes a MySQL database from Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to remove."),
+    }),
+    annotations: {
+        title: "Remove MySQL Database",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.remove", input);
+        return ResponseFormatter.success("MySQL database removed successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlSaveEnvironment.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlSaveEnvironment = createTool({
+    name: "mysql-saveEnvironment",
+    description: "Saves environment variables for a MySQL database in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to configure."),
+        env: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("Environment variables to set for the MySQL database."),
+    }),
+    annotations: {
+        title: "Save MySQL Environment Variables",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.saveEnvironment", input);
+        return ResponseFormatter.success("MySQL environment variables saved successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlSaveExternalPort.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlSaveExternalPort = createTool({
+    name: "mysql-saveExternalPort",
+    description: "Saves external port configuration for a MySQL database in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to configure."),
+        externalPort: z
+            .number()
+            .nullable()
+            .describe("The external port number to expose the database on."),
+    }),
+    annotations: {
+        title: "Save MySQL External Port",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.saveExternalPort", input);
+        return ResponseFormatter.success("MySQL external port configuration saved successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlStart.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlStart = createTool({
+    name: "mysql-start",
+    description: "Starts a MySQL database in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to start."),
+    }),
+    annotations: {
+        title: "Start MySQL Database",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.start", input);
+        return ResponseFormatter.success("MySQL database started successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlStop.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlStop = createTool({
+    name: "mysql-stop",
+    description: "Stops a MySQL database in Platform.",
+    schema: z.object({
+        mysqlId: z.string().describe("The ID of the MySQL database to stop."),
+    }),
+    annotations: {
+        title: "Stop MySQL Database",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.stop", input);
+        return ResponseFormatter.success("MySQL database stopped successfully", response.data);
+    },
+});

package/build/mcp/tools/mysql/mysqlUpdate.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const mysqlUpdate = createTool({
+    name: "mysql-update",
+    description: "Updates a MySQL database configuration in Platform.",
+    schema: z.object({
+        mysqlId: z
+            .string()
+            .min(1)
+            .describe("The ID of the MySQL database to update."),
+        name: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("The name of the MySQL database."),
+        appName: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("The app name for the MySQL database."),
+        description: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("An optional description for the database."),
+        databaseName: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("The name of the database."),
+        databaseUser: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("The username for database access."),
+        databasePassword: z
+            .string()
+            .optional()
+            .describe("The password for database access."),
+        databaseRootPassword: z
+            .string()
+            .optional()
+            .describe("The root password for MySQL."),
+        dockerImage: z
+            .string()
+            .optional()
+            .default("mysql:8")
+            .describe("Docker image to use for MySQL."),
+        command: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("Custom command to run in the container."),
+        env: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("Environment variables for the database."),
+        memoryReservation: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("Memory reservation for the container."),
+        memoryLimit: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("Memory limit for the container."),
+        cpuReservation: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("CPU reservation for the container."),
+        cpuLimit: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("CPU limit for the container."),
+        externalPort: z
+            .number()
+            .nullable()
+            .optional()
+            .describe("External port to expose the database on."),
+        applicationStatus: z
+            .enum(["idle", "running", "done", "error"])
+            .optional()
+            .describe("The status of the MySQL database."),
+        createdAt: z.string().optional().describe("Creation timestamp."),
+        projectId: z.string().optional().describe("The ID of the project."),
+    }),
+    annotations: {
+        title: "Update MySQL Database",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/mysql.update", input);
+        return ResponseFormatter.success("MySQL database updated successfully", response.data);
+    },
+});

package/build/mcp/tools/postgres/index.js

@@ -0,0 +1,13 @@
+export { postgresChangeStatus } from "./postgresChangeStatus.js";
+export { postgresCreate } from "./postgresCreate.js";
+export { postgresDeploy } from "./postgresDeploy.js";
+export { postgresMove } from "./postgresMove.js";
+export { postgresOne } from "./postgresOne.js";
+export { postgresRebuild } from "./postgresRebuild.js";
+export { postgresReload } from "./postgresReload.js";
+export { postgresRemove } from "./postgresRemove.js";
+export { postgresSaveEnvironment } from "./postgresSaveEnvironment.js";
+export { postgresSaveExternalPort } from "./postgresSaveExternalPort.js";
+export { postgresStart } from "./postgresStart.js";
+export { postgresStop } from "./postgresStop.js";
+export { postgresUpdate } from "./postgresUpdate.js";

package/build/mcp/tools/postgres/postgresChangeStatus.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const postgresChangeStatus = createTool({
+    name: "postgres-changeStatus",
+    description: "Changes the status of a PostgreSQL database in Platform.",
+    schema: z.object({
+        postgresId: z
+            .string()
+            .describe("The ID of the PostgreSQL database to change status for."),
+        applicationStatus: z
+            .enum(["idle", "running", "done", "error"])
+            .describe("The new status for the PostgreSQL database."),
+    }),
+    annotations: {
+        title: "Change PostgreSQL Database Status",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/postgres.changeStatus", input);
+        return ResponseFormatter.success(`PostgreSQL database "${input.postgresId}" status changed to "${input.applicationStatus}" successfully`, response.data);
+    },
+});

package/build/mcp/tools/postgres/postgresCreate.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const postgresCreate = createTool({
+    name: "postgres-create",
+    description: "Creates a new PostgreSQL database in Platform.",
+    schema: z.object({
+        name: z.string().min(1).describe("The name of the PostgreSQL database."),
+        appName: z.string().describe("The app name for the PostgreSQL database."),
+        databaseName: z
+            .string()
+            .min(1)
+            .describe("The name of the database to create."),
+        databaseUser: z
+            .string()
+            .min(1)
+            .describe("The username for database access."),
+        databasePassword: z.string().describe("The password for database access."),
+        dockerImage: z
+            .string()
+            .optional()
+            .describe("Docker image to use for PostgreSQL."),
+        projectId: z
+            .string()
+            .describe("The ID of the project where the database will be created."),
+        description: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("An optional description for the database."),
+        serverId: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("The ID of the server where the database will be deployed."),
+    }),
+    annotations: {
+        title: "Create PostgreSQL Database",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/postgres.create", input);
+        return ResponseFormatter.success(`PostgreSQL database "${input.name}" created successfully`, response.data);
+    },
+});

package/build/mcp/tools/postgres/postgresDeploy.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const postgresDeploy = createTool({
+    name: "postgres-deploy",
+    description: "Deploys a PostgreSQL database in Platform.",
+    schema: z.object({
+        postgresId: z
+            .string()
+            .describe("The ID of the PostgreSQL database to deploy."),
+    }),
+    annotations: {
+        title: "Deploy PostgreSQL Database",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/postgres.deploy", input);
+        return ResponseFormatter.success(`PostgreSQL database "${input.postgresId}" deployment started successfully`, response.data);
+    },
+});

package/build/mcp/tools/postgres/postgresMove.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const postgresMove = createTool({
+    name: "postgres-move",
+    description: "Moves a PostgreSQL database to a different project in Platform.",
+    schema: z.object({
+        postgresId: z
+            .string()
+            .describe("The ID of the PostgreSQL database to move."),
+        targetProjectId: z
+            .string()
+            .describe("The ID of the target project to move the database to."),
+    }),
+    annotations: {
+        title: "Move PostgreSQL Database",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/postgres.move", input);
+        return ResponseFormatter.success(`PostgreSQL database "${input.postgresId}" moved to project "${input.targetProjectId}" successfully`, response.data);
+    },
+});

package/build/mcp/tools/postgres/postgresOne.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const postgresOne = createTool({
+    name: "postgres-one",
+    description: "Gets a specific PostgreSQL database by its ID in Platform.",
+    schema: z.object({
+        postgresId: z
+            .string()
+            .describe("The ID of the PostgreSQL database to retrieve."),
+    }),
+    annotations: {
+        title: "Get PostgreSQL Database Details",
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const postgres = await apiClient.get(`/postgres.one?postgresId=${input.postgresId}`);
+        if (!postgres?.data) {
+            return ResponseFormatter.error("Failed to fetch PostgreSQL database", `PostgreSQL database with ID "${input.postgresId}" not found`);
+        }
+        return ResponseFormatter.success(`Successfully fetched PostgreSQL database "${input.postgresId}"`, postgres.data);
+    },
+});

package/build/mcp/tools/postgres/postgresRebuild.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const postgresRebuild = createTool({
+    name: "postgres-rebuild",
+    description: "Rebuilds a PostgreSQL database in Platform.",
+    schema: z.object({
+        postgresId: z
+            .string()
+            .describe("The ID of the PostgreSQL database to rebuild."),
+    }),
+    annotations: {
+        title: "Rebuild PostgreSQL Database",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/postgres.rebuild", input);
+        return ResponseFormatter.success(`PostgreSQL database "${input.postgresId}" rebuild started successfully`, response.data);
+    },
+});

package/build/mcp/tools/postgres/postgresReload.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const postgresReload = createTool({
+    name: "postgres-reload",
+    description: "Reloads a PostgreSQL database in Platform.",
+    schema: z.object({
+        postgresId: z
+            .string()
+            .describe("The ID of the PostgreSQL database to reload."),
+        appName: z
+            .string()
+            .describe("The app name of the PostgreSQL database to reload."),
+    }),
+    annotations: {
+        title: "Reload PostgreSQL Database",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/postgres.reload", input);
+        return ResponseFormatter.success(`PostgreSQL database "${input.postgresId}" reloaded successfully`, response.data);
+    },
+});

package/build/mcp/tools/postgres/postgresRemove.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const postgresRemove = createTool({
+    name: "postgres-remove",
+    description: "Removes/deletes a PostgreSQL database from Platform.",
+    schema: z.object({
+        postgresId: z
+            .string()
+            .describe("The ID of the PostgreSQL database to remove."),
+    }),
+    annotations: {
+        title: "Remove PostgreSQL Database",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/postgres.remove", input);
+        return ResponseFormatter.success(`PostgreSQL database "${input.postgresId}" removed successfully`, response.data);
+    },
+});