@takashito/linode-mcp-server/dist/tools/instances/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.registerInstanceTools = registerInstanceTools;
const client_1 = require("../../client");
const schemas = __importStar(require("./schemas"));
const errorHandler_1 = require("../common/errorHandler");
function registerInstanceTools(server) {
    // Instance operations
    server.addTool({
        name: 'list_instances',
        description: 'Get a list of all Linode instances',
        parameters: schemas.listInstancesSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const paginationParams = {
                page: params.page,
                page_size: params.page_size
            };
            const result = await (0, client_1.createClient)(context, server).instances.getLinodes(paginationParams);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_instance',
        description: 'Get details for a specific Linode instance',
        parameters: schemas.getInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeById(params.id);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'create_instance',
        description: 'Create a new Linode instance',
        parameters: schemas.createInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const createParams = {
                region: String(params.region),
                type: String(params.type),
                label: String(params.label),
                root_pass: params.root_pass,
                image: params.image,
                authorized_keys: params.authorized_keys,
                authorized_users: params.authorized_users,
                backups_enabled: params.backups_enabled,
                booted: params.booted,
                private_ip: params.private_ip,
                tags: params.tags,
                group: params.group,
                firewall_id: params.firewall_id
            };
            const result = await (0, client_1.createClient)(context, server).instances.createLinode(createParams);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'update_instance',
        description: 'Update a Linode instance',
        parameters: schemas.updateInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { id, ...updateParams } = params;
            const updateData = {
                label: updateParams.label,
                tags: updateParams.tags,
                group: updateParams.group,
                alerts: updateParams.alerts
            };
            const result = await (0, client_1.createClient)(context, server).instances.updateLinode(Number(id), updateData);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'reboot_instance',
        description: 'Reboot a Linode instance',
        parameters: schemas.rebootInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.rebootLinode(params.id, params.config_id);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'boot_instance',
        description: 'Power on a Linode instance',
        parameters: schemas.bootInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.bootLinode(params.id, params.config_id);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'shutdown_instance',
        description: 'Power off a Linode instance',
        parameters: schemas.shutdownInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.shutdownLinode(params.id);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'delete_instance',
        description: 'Delete a Linode instance',
        parameters: schemas.deleteInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.deleteLinode(params.id);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'resize_instance',
        description: 'Resize a Linode instance',
        parameters: schemas.resizeInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { id, ...resizeData } = params;
            const result = await (0, client_1.createClient)(context, server).instances.resizeLinode(id, resizeData);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'clone_instance',
        description: 'Clone a Linode instance',
        parameters: schemas.cloneInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { id, ...cloneData } = params;
            const result = await (0, client_1.createClient)(context, server).instances.cloneLinode(Number(id), cloneData);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'rebuild_instance',
        description: 'Rebuild a Linode instance',
        parameters: schemas.rebuildInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { id, ...rebuildData } = params;
            const result = await (0, client_1.createClient)(context, server).instances.rebuildLinode(id, rebuildData);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'rescue_instance',
        description: 'Boot a Linode instance into rescue mode',
        parameters: schemas.rescueInstanceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { id, devices } = params;
            const result = await (0, client_1.createClient)(context, server).instances.rescueLinode(id, devices);
            return JSON.stringify(result, null, 2);
        })
    });
    // Config operations
    server.addTool({
        name: 'list_instance_configs',
        description: 'Get all configuration profiles for a Linode instance',
        parameters: schemas.getLinodeConfigsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, page, page_size } = params;
            const paginationParams = {
                page,
                page_size
            };
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeConfigs(linodeId, paginationParams);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_instance_config',
        description: 'Get a specific configuration profile for a Linode instance',
        parameters: schemas.getLinodeConfigSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeConfig(params.linodeId, params.configId);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'create_instance_config',
        description: 'Create a new configuration profile for a Linode instance',
        parameters: schemas.createLinodeConfigSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, ...configData } = params;
            const result = await (0, client_1.createClient)(context, server).instances.createLinodeConfig(linodeId, configData);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'update_instance_config',
        description: 'Update a configuration profile for a Linode instance',
        parameters: schemas.updateLinodeConfigSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, configId, ...updateData } = params;
            const result = await (0, client_1.createClient)(context, server).instances.updateLinodeConfig(linodeId, configId, updateData);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'delete_instance_config',
        description: 'Delete a configuration profile for a Linode instance',
        parameters: schemas.deleteLinodeConfigSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.deleteLinodeConfig(params.linodeId, params.configId);
            return JSON.stringify(result, null, 2);
        })
    });
    // Disk operations
    server.addTool({
        name: 'list_instance_disks',
        description: 'Get all disks for a Linode instance',
        parameters: schemas.getLinodeDisksSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, page, page_size } = params;
            const paginationParams = {
                page,
                page_size
            };
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeDisks(linodeId, paginationParams);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_instance_disk',
        description: 'Get a specific disk for a Linode instance',
        parameters: schemas.getLinodeDiskSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeDisk(params.linodeId, params.diskId);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'create_instance_disk',
        description: 'Create a new disk for a Linode instance',
        parameters: schemas.createLinodeDiskSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, ...diskData } = params;
            const result = await (0, client_1.createClient)(context, server).instances.createLinodeDisk(linodeId, diskData);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'update_instance_disk',
        description: 'Update a disk for a Linode instance',
        parameters: schemas.updateLinodeDiskSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, diskId, ...updateData } = params;
            const result = await (0, client_1.createClient)(context, server).instances.updateLinodeDisk(linodeId, diskId, updateData);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'delete_instance_disk',
        description: 'Delete a disk for a Linode instance',
        parameters: schemas.deleteLinodeDiskSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.deleteLinodeDisk(params.linodeId, params.diskId);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'resize_instance_disk',
        description: 'Resize a disk for a Linode instance',
        parameters: schemas.resizeLinodeDiskSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.resizeLinodeDisk(params.linodeId, params.diskId, params.size);
            return JSON.stringify(result, null, 2);
        })
    });
    // Stats operations
    server.addTool({
        name: 'get_instance_stats',
        description: 'Get current statistics for a Linode instance',
        parameters: schemas.getLinodeStatsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeStats(params.id);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_instance_stats_by_date',
        description: 'Get statistics for a Linode instance for a specific month',
        parameters: schemas.getLinodeStatsByDateSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeStatsByDate(params.id, params.year, params.month);
            return JSON.stringify(result, null, 2);
        })
    });
    // Backup operations
    server.addTool({
        name: 'list_backups',
        description: 'Get a list of all backups for a Linode instance',
        parameters: schemas.getBackupsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getBackups(params.linodeId);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_backup',
        description: 'Get details for a specific backup',
        parameters: schemas.getBackupSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getBackup(params.linodeId, params.backupId);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'create_snapshot',
        description: 'Create a snapshot for a Linode instance',
        parameters: schemas.createSnapshotSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, ...data } = params;
            const result = await (0, client_1.createClient)(context, server).instances.createSnapshot(linodeId, data);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'cancel_backups',
        description: 'Cancel backups for a Linode instance',
        parameters: schemas.cancelBackupsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            await (0, client_1.createClient)(context, server).instances.cancelBackups(params.linodeId);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    server.addTool({
        name: 'enable_backups',
        description: 'Enable backups for a Linode instance',
        parameters: schemas.enableBackupsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            await (0, client_1.createClient)(context, server).instances.enableBackups(params.linodeId);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    server.addTool({
        name: 'restore_backup',
        description: 'Restore a backup to a Linode instance',
        parameters: schemas.restoreBackupSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, backupId, ...data } = params;
            await (0, client_1.createClient)(context, server).instances.restoreBackup(linodeId, backupId, data);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    // IP operations
    server.addTool({
        name: 'get_networking_information',
        description: 'Get networking information for a Linode instance',
        parameters: schemas.getLinodeIPsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeIPs(params.linodeId);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'allocate_ipv4_address',
        description: 'Allocate an IPv4 address for a Linode instance',
        parameters: schemas.linodeAllocateIPSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, ...data } = params;
            const result = await (0, client_1.createClient)(context, server).instances.allocateIP(linodeId, data);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_instance_ip_address',
        description: 'Get details for a specific IP address for a Linode instance',
        parameters: schemas.getLinodeIPSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeIP(params.linodeId, params.address);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'update_ip_address_rdns',
        description: 'Update the RDNS for an IP address of a Linode instance',
        parameters: schemas.updateLinodeIPSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, address, ...data } = params;
            const result = await (0, client_1.createClient)(context, server).instances.updateLinodeIP(linodeId, address, data);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'delete_ipv4_address',
        description: 'Delete an IPv4 address from a Linode instance',
        parameters: schemas.deleteLinodeIPSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            await (0, client_1.createClient)(context, server).instances.deleteLinodeIP(params.linodeId, params.address);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    // Firewall operations
    server.addTool({
        name: 'list_linode_firewalls',
        description: 'List firewalls for a Linode instance',
        parameters: schemas.getLinodeFirewallsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, page, page_size } = params;
            const paginationParams = { page, page_size };
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeFirewalls(linodeId, paginationParams);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'apply_linode_firewalls',
        description: 'Apply firewalls to a Linode instance',
        parameters: schemas.applyFirewallsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            await (0, client_1.createClient)(context, server).instances.applyFirewalls(params.linodeId);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    // Additional disk operations
    server.addTool({
        name: 'clone_disk',
        description: 'Clone a disk for a Linode instance',
        parameters: schemas.cloneDiskSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, diskId, label } = params;
            const result = await (0, client_1.createClient)(context, server).instances.cloneDisk(linodeId, diskId, label ? { label } : undefined);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'reset_disk_root_password',
        description: 'Reset the root password for a disk',
        parameters: schemas.resetDiskPasswordSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            await (0, client_1.createClient)(context, server).instances.resetDiskPassword(params.linodeId, params.diskId, params.password);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    // Migration and upgrade operations
    server.addTool({
        name: 'initiate_migration',
        description: 'Initiate a migration for a Linode instance',
        parameters: schemas.migrateLinodeSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { id, region } = params;
            await (0, client_1.createClient)(context, server).instances.migrateLinode(id, region ? { region } : undefined);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    server.addTool({
        name: 'upgrade_linode',
        description: 'Upgrade a Linode instance',
        parameters: schemas.mutateLinodeSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            await (0, client_1.createClient)(context, server).instances.mutateLinode(params.id);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    // Reset root password operation
    server.addTool({
        name: 'reset_root_password',
        description: 'Reset the root password for a Linode instance. Your Linode must be shut down for a password reset to complete.',
        parameters: schemas.resetRootPasswordSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { id, ...data } = params;
            await (0, client_1.createClient)(context, server).instances.resetRootPassword(id, data);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    // Transfer operations
    server.addTool({
        name: 'get_network_transfer',
        description: 'Get network transfer information for a Linode instance',
        parameters: schemas.getNetworkTransferSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getNetworkTransfer(params.id);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_monthly_network_transfer',
        description: 'Get monthly network transfer stats for a Linode instance',
        parameters: schemas.getMonthlyTransferSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getMonthlyTransfer(params.id, params.year, params.month);
            return JSON.stringify(result, null, 2);
        })
    });
    // Kernel operations
    server.addTool({
        name: 'list_kernels',
        description: 'Get a list of all available kernels',
        parameters: schemas.listKernelsSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const paginationParams = {
                page: params.page,
                page_size: params.page_size
            };
            const result = await (0, client_1.createClient)(context, server).instances.getKernels(paginationParams);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_kernel',
        description: 'Get details for a specific kernel',
        parameters: schemas.getKernelSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getKernelById(params.id);
            return JSON.stringify(result, null, 2);
        })
    });
    // Instance Type operations
    server.addTool({
        name: 'list_instance_types',
        description: 'Get a list of all available Linode types, including pricing and specifications',
        parameters: schemas.listInstanceTypesSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const paginationParams = {
                page: params.page,
                page_size: params.page_size
            };
            const result = await (0, client_1.createClient)(context, server).instances.getTypes(paginationParams);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_instance_type',
        description: 'Get details for a specific Linode type, including pricing and specifications',
        parameters: schemas.getInstanceTypeSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getType(params.id);
            return JSON.stringify(result, null, 2);
        })
    });
    // Config Interface operations
    server.addTool({
        name: 'list_config_interfaces',
        description: 'List all interfaces for a configuration profile',
        parameters: schemas.getConfigInterfacesSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getConfigInterfaces(params.linodeId, params.configId);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'get_config_interface',
        description: 'Get details for a specific configuration profile interface',
        parameters: schemas.getConfigInterfaceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const result = await (0, client_1.createClient)(context, server).instances.getConfigInterface(params.linodeId, params.configId, params.interfaceId);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'create_config_interface',
        description: 'Create a new interface for a configuration profile',
        parameters: schemas.createConfigInterfaceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, configId, ...data } = params;
            const result = await (0, client_1.createClient)(context, server).instances.createConfigInterface(linodeId, configId, data);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'update_config_interface',
        description: 'Update an interface for a configuration profile',
        parameters: schemas.updateConfigInterfaceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, configId, interfaceId, ...data } = params;
            const result = await (0, client_1.createClient)(context, server).instances.updateConfigInterface(linodeId, configId, interfaceId, data);
            return JSON.stringify(result, null, 2);
        })
    });
    server.addTool({
        name: 'delete_config_interface',
        description: 'Delete an interface from a configuration profile',
        parameters: schemas.deleteConfigInterfaceSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            await (0, client_1.createClient)(context, server).instances.deleteConfigInterface(params.linodeId, params.configId, params.interfaceId);
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    server.addTool({
        name: 'reorder_config_interfaces',
        description: 'Reorder interfaces for a configuration profile',
        parameters: schemas.reorderConfigInterfacesSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, configId, ids } = params;
            await (0, client_1.createClient)(context, server).instances.reorderConfigInterfaces(linodeId, configId, { ids });
            return JSON.stringify({ success: true }, null, 2);
        })
    });
    // NodeBalancer operations for instance
    server.addTool({
        name: 'list_instance_nodebalancers',
        description: 'List NodeBalancers attached to a Linode instance',
        parameters: schemas.getLinodeNodeBalancersSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, page, page_size } = params;
            const paginationParams = {
                page,
                page_size
            };
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeNodeBalancers(linodeId, paginationParams);
            return JSON.stringify(result, null, 2);
        })
    });
    // Volume operations for instance
    server.addTool({
        name: 'list_instance_volumes',
        description: 'List volumes attached to a Linode instance',
        parameters: schemas.getLinodeVolumesSchema,
        execute: (0, errorHandler_1.withErrorHandling)(async (params, context) => {
            const { linodeId, page, page_size } = params;
            const paginationParams = {
                page,
                page_size
            };
            const result = await (0, client_1.createClient)(context, server).instances.getLinodeVolumes(linodeId, paginationParams);
            return JSON.stringify(result, null, 2);
        })
    });
}
//# sourceMappingURL=tools.js.map