@takashito/linode-mcp-server/dist/tools/placement/tools.js

MCP server for Linode API

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.registerPlacementTools = registerPlacementTools;
const client_1 = require("../../client");
const schemas = __importStar(require("./schemas"));
const errorHandler_1 = require("../common/errorHandler");
function registerPlacementTools(server, client) {
    // Register placement tools
    server.addTool({
        name: 'list_placement_groups',
        description: 'List all placement groups',
        parameters: schemas.listPlacementGroupsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            try {
                const paginationParams = {
                    page: params.page,
                    page_size: params.page_size
                };
                const result = await (0, client_1.createClient)(context, server).placement.getPlacementGroups(paginationParams);
                // Check if result and result.data exist before accessing properties
                if (!result || !result.data) {
                    return {
                        content: [
                            { type: 'text', text: "No placement groups found or empty response received." },
                        ],
                    };
                }
                return {
                    content: [
                        { type: 'text', text: formatPlacementGroups(result.data) },
                    ],
                };
            }
            catch (error) {
                // Handle error gracefully
                const errorMessage = error?.message || 'Unknown error occurred';
                return {
                    content: [
                        { type: 'text', text: `Error retrieving placement groups: ${errorMessage}` },
                    ],
                };
            }
        })
    });
    server.addTool({
        name: 'get_placement_group',
        description: 'Get details for a specific placement group',
        parameters: schemas.getPlacementGroupSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            try {
                if (!params || params.id === undefined || params.id === null) {
                    return {
                        content: [
                            { type: 'text', text: "Error: Placement group ID is required" },
                        ],
                    };
                }
                const result = await (0, client_1.createClient)(context, server).placement.getPlacementGroup(params.id);
                if (!result) {
                    return {
                        content: [
                            { type: 'text', text: `No placement group found with ID ${params.id}` },
                        ],
                    };
                }
                return {
                    content: [
                        { type: 'text', text: formatPlacementGroup(result) },
                    ],
                };
            }
            catch (error) {
                const errorMessage = error?.message || 'Unknown error occurred';
                return {
                    content: [
                        { type: 'text', text: `Error retrieving placement group: ${errorMessage}` },
                    ],
                };
            }
        })
    });
    server.addTool({
        name: 'create_placement_group',
        description: 'Create a new placement group',
        parameters: schemas.createPlacementGroupSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            try {
                const result = await (0, client_1.createClient)(context, server).placement.createPlacementGroup(params);
                return JSON.stringify(result, null, 2);
            }
            catch (error) {
                const errorMessage = error?.message || 'Unknown error occurred';
                return {
                    content: [
                        { type: 'text', text: `Error creating placement group: ${errorMessage}` },
                    ],
                };
            }
        })
    });
    server.addTool({
        name: 'update_placement_group',
        description: 'Update an existing placement group',
        parameters: schemas.updatePlacementGroupSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            try {
                const { id, ...data } = params;
                const result = await (0, client_1.createClient)(context, server).placement.updatePlacementGroup(id, data);
                return JSON.stringify(result, null, 2);
            }
            catch (error) {
                const errorMessage = error?.message || 'Unknown error occurred';
                return {
                    content: [
                        { type: 'text', text: `Error updating placement group: ${errorMessage}` },
                    ],
                };
            }
        })
    });
    server.addTool({
        name: 'delete_placement_group',
        description: 'Delete a placement group',
        parameters: schemas.deletePlacementGroupSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            try {
                await (0, client_1.createClient)(context, server).placement.deletePlacementGroup(params.id);
                return JSON.stringify({ success: true }, null, 2);
            }
            catch (error) {
                const errorMessage = error?.message || 'Unknown error occurred';
                return {
                    content: [
                        { type: 'text', text: `Error deleting placement group: ${errorMessage}` },
                    ],
                };
            }
        })
    });
    server.addTool({
        name: 'assign_instances',
        description: 'Assign Linode instances to a placement group',
        parameters: schemas.assignInstancesSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            try {
                const result = await (0, client_1.createClient)(context, server).placement.assignInstances(params.id, { linodes: params.linodes });
                return JSON.stringify(result, null, 2);
            }
            catch (error) {
                const errorMessage = error?.message || 'Unknown error occurred';
                return {
                    content: [
                        { type: 'text', text: `Error assigning instances to placement group: ${errorMessage}` },
                    ],
                };
            }
        })
    });
    server.addTool({
        name: 'unassign_instances',
        description: 'Unassign Linode instances from a placement group',
        parameters: schemas.unassignInstancesSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            try {
                const result = await (0, client_1.createClient)(context, server).placement.unassignInstances(params.id, { linodes: params.linodes });
                return JSON.stringify(result, null, 2);
            }
            catch (error) {
                const errorMessage = error?.message || 'Unknown error occurred';
                return {
                    content: [
                        { type: 'text', text: `Error unassigning instances from placement group: ${errorMessage}` },
                    ],
                };
            }
        })
    });
}
/**
 * Formats a placement group for display
 */
function formatPlacementGroup(group) {
    // Handle null or undefined input
    if (!group) {
        return 'No placement group data available.';
    }
    // Safely access properties with null checks
    const details = [
        `ID: ${group.id || 'Unknown ID'}`,
        `Label: ${group.label || 'Unnamed'}`,
        `Type: ${group.placement_group_type || 'Unknown type'}`,
        `Policy: ${group.placement_group_policy || 'Unknown policy'}`,
        `Region: ${group.region || 'Unknown region'}`,
    ];
    // Safely handle linodes array
    if (group.linodes && Array.isArray(group.linodes)) {
        details.push(`Linodes: ${group.linodes.length > 0 ? group.linodes.join(', ') : 'None'}`);
    }
    else {
        details.push('Linodes: None');
    }
    // Safely handle dates
    if (group.created) {
        try {
            details.push(`Created: ${new Date(group.created).toLocaleString()}`);
        }
        catch (e) {
            details.push(`Created: ${group.created}`);
        }
    }
    if (group.updated) {
        try {
            details.push(`Updated: ${new Date(group.updated).toLocaleString()}`);
        }
        catch (e) {
            details.push(`Updated: ${group.updated}`);
        }
    }
    // Safely handle tags
    if (group.tags && Array.isArray(group.tags) && group.tags.length > 0) {
        details.push(`Tags: ${group.tags.join(', ')}`);
    }
    return details.join('\n');
}
/**
 * Formats placement groups for display
 */
function formatPlacementGroups(groups) {
    // Handle null or undefined input
    if (!groups) {
        return 'No placement groups data available.';
    }
    // Handle empty array
    if (groups.length === 0) {
        return 'No placement groups found.';
    }
    const formattedGroups = groups.map((group) => {
        // Safely access properties with null checks
        const label = group.label || 'Unnamed';
        const id = group.id || 'Unknown ID';
        const region = group.region || 'Unknown region';
        const type = group.placement_group_type || 'Unknown type';
        const policy = group.placement_group_policy || 'Unknown policy';
        const linodesCount = group.linodes && Array.isArray(group.linodes) ? group.linodes.length : 0;
        return `${label} (ID: ${id}, Region: ${region}, Type: ${type}, Policy: ${policy}, Linodes: ${linodesCount})`;
    });
    return formattedGroups.join('\n');
}
//# sourceMappingURL=tools.js.map