@softtor/coolify-mcp-server 1.0.0

package/dist/tools/applications.d.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+export declare const ListApplicationsSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    team?: string | undefined;
+}, {
+    team?: string | undefined;
+}>;
+export declare const GetApplicationSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const StartApplicationSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const StopApplicationSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const RestartApplicationSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const GetApplicationLogsSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+} & {
+    since: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+    since?: number | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+    since?: number | undefined;
+}>;
+export declare function listApplications(params: z.infer<typeof ListApplicationsSchema>): Promise<string>;
+export declare function getApplication(params: z.infer<typeof GetApplicationSchema>): Promise<string>;
+export declare function startApplication(params: z.infer<typeof StartApplicationSchema>): Promise<string>;
+export declare function stopApplication(params: z.infer<typeof StopApplicationSchema>): Promise<string>;
+export declare function restartApplication(params: z.infer<typeof RestartApplicationSchema>): Promise<string>;
+export declare function getApplicationLogs(params: z.infer<typeof GetApplicationLogsSchema>): Promise<string>;
+export declare const applicationTools: ({
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        team?: string | undefined;
+    }, {
+        team?: string | undefined;
+    }>;
+    handler: typeof listApplications;
+} | {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    } & {
+        uuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        team?: string | undefined;
+    }, {
+        uuid: string;
+        team?: string | undefined;
+    }>;
+    handler: typeof getApplication;
+} | {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    } & {
+        uuid: z.ZodString;
+    } & {
+        since: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        team?: string | undefined;
+        since?: number | undefined;
+    }, {
+        uuid: string;
+        team?: string | undefined;
+        since?: number | undefined;
+    }>;
+    handler: typeof getApplicationLogs;
+})[];

package/dist/tools/applications.js

@@ -0,0 +1,80 @@
+import { coolifyGet, coolifyPost } from "../services/coolify-client.js";
+import { TeamParamSchema, UuidParamSchema, LogsParamSchema } from "../schemas/common.js";
+export const ListApplicationsSchema = TeamParamSchema;
+export const GetApplicationSchema = UuidParamSchema;
+export const StartApplicationSchema = UuidParamSchema;
+export const StopApplicationSchema = UuidParamSchema;
+export const RestartApplicationSchema = UuidParamSchema;
+export const GetApplicationLogsSchema = LogsParamSchema;
+export async function listApplications(params) {
+    const data = await coolifyGet("/applications", { team: params.team });
+    return JSON.stringify(data, null, 2);
+}
+export async function getApplication(params) {
+    const data = await coolifyGet(`/applications/${params.uuid}`, { team: params.team });
+    return JSON.stringify(data, null, 2);
+}
+export async function startApplication(params) {
+    const data = await coolifyPost(`/applications/${params.uuid}/start`, undefined, {
+        team: params.team,
+    });
+    return JSON.stringify(data, null, 2);
+}
+export async function stopApplication(params) {
+    const data = await coolifyPost(`/applications/${params.uuid}/stop`, undefined, {
+        team: params.team,
+    });
+    return JSON.stringify(data, null, 2);
+}
+export async function restartApplication(params) {
+    const data = await coolifyPost(`/applications/${params.uuid}/restart`, undefined, {
+        team: params.team,
+    });
+    return JSON.stringify(data, null, 2);
+}
+export async function getApplicationLogs(params) {
+    const since = params.since ?? 3600;
+    const data = await coolifyGet(`/applications/${params.uuid}/logs`, {
+        team: params.team,
+        params: { since },
+    });
+    return JSON.stringify(data, null, 2);
+}
+export const applicationTools = [
+    {
+        name: "coolify_list_applications",
+        description: "List all applications in Coolify",
+        inputSchema: ListApplicationsSchema,
+        handler: listApplications,
+    },
+    {
+        name: "coolify_get_application",
+        description: "Get details of a specific application by UUID",
+        inputSchema: GetApplicationSchema,
+        handler: getApplication,
+    },
+    {
+        name: "coolify_start_application",
+        description: "Start/deploy an application",
+        inputSchema: StartApplicationSchema,
+        handler: startApplication,
+    },
+    {
+        name: "coolify_stop_application",
+        description: "Stop a running application",
+        inputSchema: StopApplicationSchema,
+        handler: stopApplication,
+    },
+    {
+        name: "coolify_restart_application",
+        description: "Restart an application",
+        inputSchema: RestartApplicationSchema,
+        handler: restartApplication,
+    },
+    {
+        name: "coolify_get_application_logs",
+        description: "Get container logs for an application",
+        inputSchema: GetApplicationLogsSchema,
+        handler: getApplicationLogs,
+    },
+];

package/dist/tools/databases.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+export declare const ListDatabasesSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    team?: string | undefined;
+}, {
+    team?: string | undefined;
+}>;
+export declare const GetDatabaseSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const StartDatabaseSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const StopDatabaseSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const RestartDatabaseSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const ListDatabaseBackupsSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare function listDatabases(params: z.infer<typeof ListDatabasesSchema>): Promise<string>;
+export declare function getDatabase(params: z.infer<typeof GetDatabaseSchema>): Promise<string>;
+export declare function startDatabase(params: z.infer<typeof StartDatabaseSchema>): Promise<string>;
+export declare function stopDatabase(params: z.infer<typeof StopDatabaseSchema>): Promise<string>;
+export declare function restartDatabase(params: z.infer<typeof RestartDatabaseSchema>): Promise<string>;
+export declare function listDatabaseBackups(params: z.infer<typeof ListDatabaseBackupsSchema>): Promise<string>;
+export declare const databaseTools: ({
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        team?: string | undefined;
+    }, {
+        team?: string | undefined;
+    }>;
+    handler: typeof listDatabases;
+} | {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    } & {
+        uuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        team?: string | undefined;
+    }, {
+        uuid: string;
+        team?: string | undefined;
+    }>;
+    handler: typeof getDatabase;
+})[];

package/dist/tools/databases.js

@@ -0,0 +1,78 @@
+import { coolifyGet, coolifyPost } from "../services/coolify-client.js";
+import { TeamParamSchema, UuidParamSchema } from "../schemas/common.js";
+export const ListDatabasesSchema = TeamParamSchema;
+export const GetDatabaseSchema = UuidParamSchema;
+export const StartDatabaseSchema = UuidParamSchema;
+export const StopDatabaseSchema = UuidParamSchema;
+export const RestartDatabaseSchema = UuidParamSchema;
+export const ListDatabaseBackupsSchema = UuidParamSchema;
+export async function listDatabases(params) {
+    const data = await coolifyGet("/databases", { team: params.team });
+    return JSON.stringify(data, null, 2);
+}
+export async function getDatabase(params) {
+    const data = await coolifyGet(`/databases/${params.uuid}`, { team: params.team });
+    return JSON.stringify(data, null, 2);
+}
+export async function startDatabase(params) {
+    const data = await coolifyPost(`/databases/${params.uuid}/start`, undefined, {
+        team: params.team,
+    });
+    return JSON.stringify(data, null, 2);
+}
+export async function stopDatabase(params) {
+    const data = await coolifyPost(`/databases/${params.uuid}/stop`, undefined, {
+        team: params.team,
+    });
+    return JSON.stringify(data, null, 2);
+}
+export async function restartDatabase(params) {
+    const data = await coolifyPost(`/databases/${params.uuid}/restart`, undefined, {
+        team: params.team,
+    });
+    return JSON.stringify(data, null, 2);
+}
+export async function listDatabaseBackups(params) {
+    const data = await coolifyGet(`/databases/${params.uuid}/backups`, {
+        team: params.team,
+    });
+    return JSON.stringify(data, null, 2);
+}
+export const databaseTools = [
+    {
+        name: "coolify_list_databases",
+        description: "List all databases in Coolify",
+        inputSchema: ListDatabasesSchema,
+        handler: listDatabases,
+    },
+    {
+        name: "coolify_get_database",
+        description: "Get details of a specific database by UUID",
+        inputSchema: GetDatabaseSchema,
+        handler: getDatabase,
+    },
+    {
+        name: "coolify_start_database",
+        description: "Start a database",
+        inputSchema: StartDatabaseSchema,
+        handler: startDatabase,
+    },
+    {
+        name: "coolify_stop_database",
+        description: "Stop a running database",
+        inputSchema: StopDatabaseSchema,
+        handler: stopDatabase,
+    },
+    {
+        name: "coolify_restart_database",
+        description: "Restart a database",
+        inputSchema: RestartDatabaseSchema,
+        handler: restartDatabase,
+    },
+    {
+        name: "coolify_list_database_backups",
+        description: "List backups for a database",
+        inputSchema: ListDatabaseBackupsSchema,
+        handler: listDatabaseBackups,
+    },
+];

package/dist/tools/deployments.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+export declare const DeploySchema: z.ZodEffects<z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    team?: string | undefined;
+    uuid?: string | undefined;
+    tag?: string | undefined;
+    force?: boolean | undefined;
+}, {
+    team?: string | undefined;
+    uuid?: string | undefined;
+    tag?: string | undefined;
+    force?: boolean | undefined;
+}>, {
+    team?: string | undefined;
+    uuid?: string | undefined;
+    tag?: string | undefined;
+    force?: boolean | undefined;
+}, {
+    team?: string | undefined;
+    uuid?: string | undefined;
+    tag?: string | undefined;
+    force?: boolean | undefined;
+}>;
+export declare const ListDeploymentsSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+    skip: z.ZodOptional<z.ZodNumber>;
+    take: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+    skip?: number | undefined;
+    take?: number | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+    skip?: number | undefined;
+    take?: number | undefined;
+}>;
+export declare function deploy(params: z.infer<typeof DeploySchema>): Promise<string>;
+export declare function listDeployments(params: z.infer<typeof ListDeploymentsSchema>): Promise<string>;
+export declare const deploymentTools: ({
+    name: string;
+    description: string;
+    inputSchema: z.ZodEffects<z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    } & {
+        uuid: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
+        force: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        team?: string | undefined;
+        uuid?: string | undefined;
+        tag?: string | undefined;
+        force?: boolean | undefined;
+    }, {
+        team?: string | undefined;
+        uuid?: string | undefined;
+        tag?: string | undefined;
+        force?: boolean | undefined;
+    }>, {
+        team?: string | undefined;
+        uuid?: string | undefined;
+        tag?: string | undefined;
+        force?: boolean | undefined;
+    }, {
+        team?: string | undefined;
+        uuid?: string | undefined;
+        tag?: string | undefined;
+        force?: boolean | undefined;
+    }>;
+    handler: typeof deploy;
+} | {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    } & {
+        uuid: z.ZodString;
+        skip: z.ZodOptional<z.ZodNumber>;
+        take: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        team?: string | undefined;
+        skip?: number | undefined;
+        take?: number | undefined;
+    }, {
+        uuid: string;
+        team?: string | undefined;
+        skip?: number | undefined;
+        take?: number | undefined;
+    }>;
+    handler: typeof listDeployments;
+})[];

package/dist/tools/deployments.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { coolifyGet, coolifyPost } from "../services/coolify-client.js";
+import { DeployParamSchema, TeamParamSchema } from "../schemas/common.js";
+export const DeploySchema = DeployParamSchema.refine((data) => data.uuid || data.tag, { message: "Either uuid or tag must be provided" });
+export const ListDeploymentsSchema = TeamParamSchema.extend({
+    uuid: z.string().describe("Application UUID to list deployments for"),
+    skip: z.number().optional().describe("Number of deployments to skip (pagination)"),
+    take: z.number().optional().describe("Number of deployments to take (pagination)"),
+});
+export async function deploy(params) {
+    const queryParams = {};
+    if (params.uuid) {
+        queryParams.uuid = params.uuid;
+    }
+    if (params.tag) {
+        queryParams.tag = params.tag;
+    }
+    if (params.force) {
+        queryParams.force = params.force;
+    }
+    const data = await coolifyPost("/deploy", undefined, {
+        team: params.team,
+        params: queryParams,
+    });
+    return JSON.stringify(data, null, 2);
+}
+export async function listDeployments(params) {
+    const data = await coolifyGet(`/applications/${params.uuid}/deployments`, {
+        team: params.team,
+        params: {
+            skip: params.skip,
+            take: params.take,
+        },
+    });
+    return JSON.stringify(data, null, 2);
+}
+export const deploymentTools = [
+    {
+        name: "coolify_deploy",
+        description: "Deploy an application by UUID or deploy all resources with a specific tag",
+        inputSchema: DeploySchema,
+        handler: deploy,
+    },
+    {
+        name: "coolify_list_deployments",
+        description: "List deployment history for an application",
+        inputSchema: ListDeploymentsSchema,
+        handler: listDeployments,
+    },
+];

package/dist/tools/projects.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+export declare const ListProjectsSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    team?: string | undefined;
+}, {
+    team?: string | undefined;
+}>;
+export declare const GetProjectSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+} & {
+    uuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    team?: string | undefined;
+}, {
+    uuid: string;
+    team?: string | undefined;
+}>;
+export declare const ListTeamsSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    team?: string | undefined;
+}, {
+    team?: string | undefined;
+}>;
+export declare const GetTeamSchema: z.ZodObject<{
+    team: z.ZodOptional<z.ZodString>;
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    team?: string | undefined;
+}, {
+    id: number;
+    team?: string | undefined;
+}>;
+export declare function listProjects(params: z.infer<typeof ListProjectsSchema>): Promise<string>;
+export declare function getProject(params: z.infer<typeof GetProjectSchema>): Promise<string>;
+export declare function listTeams(params: z.infer<typeof ListTeamsSchema>): Promise<string>;
+export declare function getTeam(params: z.infer<typeof GetTeamSchema>): Promise<string>;
+export declare const projectTools: ({
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        team?: string | undefined;
+    }, {
+        team?: string | undefined;
+    }>;
+    handler: typeof listProjects;
+} | {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+    } & {
+        uuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        team?: string | undefined;
+    }, {
+        uuid: string;
+        team?: string | undefined;
+    }>;
+    handler: typeof getProject;
+} | {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+        id: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        team?: string | undefined;
+    }, {
+        id: number;
+        team?: string | undefined;
+    }>;
+    handler: typeof getTeam;
+})[];

package/dist/tools/projects.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { coolifyGet } from "../services/coolify-client.js";
+import { TeamParamSchema, UuidParamSchema } from "../schemas/common.js";
+export const ListProjectsSchema = TeamParamSchema;
+export const GetProjectSchema = UuidParamSchema;
+export const ListTeamsSchema = z.object({
+    team: z.string().optional().describe("Team name to use for authentication"),
+});
+export const GetTeamSchema = z.object({
+    team: z.string().optional().describe("Team name to use for authentication"),
+    id: z.number().describe("Team ID"),
+});
+export async function listProjects(params) {
+    const data = await coolifyGet("/projects", { team: params.team });
+    return JSON.stringify(data, null, 2);
+}
+export async function getProject(params) {
+    const data = await coolifyGet(`/projects/${params.uuid}`, { team: params.team });
+    return JSON.stringify(data, null, 2);
+}
+export async function listTeams(params) {
+    const data = await coolifyGet("/teams", { team: params.team });
+    return JSON.stringify(data, null, 2);
+}
+export async function getTeam(params) {
+    const data = await coolifyGet(`/teams/${params.id}`, { team: params.team });
+    return JSON.stringify(data, null, 2);
+}
+export const projectTools = [
+    {
+        name: "coolify_list_projects",
+        description: "List all projects in Coolify",
+        inputSchema: ListProjectsSchema,
+        handler: listProjects,
+    },
+    {
+        name: "coolify_get_project",
+        description: "Get details of a specific project by UUID",
+        inputSchema: GetProjectSchema,
+        handler: getProject,
+    },
+    {
+        name: "coolify_list_teams",
+        description: "List all teams accessible with current API key",
+        inputSchema: ListTeamsSchema,
+        handler: listTeams,
+    },
+    {
+        name: "coolify_get_team",
+        description: "Get details of a specific team by ID",
+        inputSchema: GetTeamSchema,
+        handler: getTeam,
+    },
+];