coolify_security_keys

Instructions

Implementation Reference

• src/handlers.ts:463-496 (handler)

  The primary handler function 'securityKeys' that executes the tool logic, handling CRUD operations (list, create, get, update, delete) for security keys by making API calls to Coolify endpoints.

    async securityKeys(action: string, args: any) {
      switch (action) {
        case 'list':
          const queryString = this.apiClient.buildQueryString(args);
          const response = await this.apiClient.get(`/security/keys?${queryString}`);
          return { content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }] };
        case 'create':
          const createResponse = await this.apiClient.post('/security/keys', {
            name: args.name,
            description: args.description,
            private_key: args.key,
          });
          return { content: [{ type: 'text', text: JSON.stringify(createResponse.data, null, 2) }] };
        case 'get':
          if (!args.uuid) throw new Error('Security key UUID is required for get action');
          const getResponse = await this.apiClient.get(`/security/keys/${args.uuid}`);
          return { content: [{ type: 'text', text: JSON.stringify(getResponse.data, null, 2) }] };
        case 'update':
          if (!args.uuid) throw new Error('Security key UUID is required for update action');
          const updateResponse = await this.apiClient.patch(`/security/keys/${args.uuid}`, {
            name: args.name,
            description: args.description,
            private_key: args.key,
          });
          return { content: [{ type: 'text', text: JSON.stringify(updateResponse.data, null, 2) }] };
        case 'delete':
          if (!args.uuid) throw new Error('Security key UUID is required for delete action');
          await this.apiClient.delete(`/security/keys/${args.uuid}`);
          return { content: [{ type: 'text', text: 'Security key deleted successfully' }] };
        default:
          throw new Error(`Unknown security keys action: ${action}`);
      }
    }
  }

• src/tools.ts:687-725 (schema)

  The tool registration and input schema definition for 'coolify_security_keys', specifying supported actions and parameters.

  {
    name: 'coolify_security_keys',
    description: 'Security keys management - list, create, get, update, and delete security keys',
    inputSchema: {
      type: 'object',
      properties: {
        action: { 
          type: 'string', 
          enum: ['list', 'create', 'get', 'update', 'delete'],
          description: 'Action to perform: list (list all security keys), create (create new security key), get (get security key by UUID), update (update security key), delete (delete security key)'
        },
        uuid: { 
          type: 'string', 
          description: 'Security key UUID (required for get, update, delete actions)' 
        },
        name: { 
          type: 'string', 
          description: 'Key name (required for create, optional for update)' 
        },
        description: { 
          type: 'string', 
          description: 'Key description (optional for create and update)' 
        },
        key: { 
          type: 'string', 
          description: 'SSH private key content (required for create, optional for update)' 
        },
        page: { 
          type: 'number', 
          description: 'Page number (optional for list action)' 
        },
        per_page: { 
          type: 'number', 
          description: 'Items per page (optional for list action)' 
        },
      },
      required: ['action'],
    },
  },

• src/index.ts:85-142 (registration)

  The tool dispatch registration in the central handleToolCall switch statement, routing 'coolify_security_keys' calls to the appropriate handler method.

  private async handleToolCall(name: string, args: any) {
    switch (name) {
      // System Management
      case 'coolify_system':
        return await this.handlers.system(args.action);
      
      // Team Management
      case 'coolify_teams':
        return await this.handlers.teams(args.action, args.team_id);
      
      // Project Management
      case 'coolify_projects':
        return await this.handlers.projects(args.action, args);
      case 'coolify_project_environments':
        return await this.handlers.projectEnvironments(args.action, args);
      
      // Application Management
      case 'coolify_applications':
        return await this.handlers.applications(args.action, args);
      case 'coolify_application_lifecycle':
        return await this.handlers.applicationLifecycle(args.action, args.uuid);
      case 'coolify_application_envs':
        return await this.handlers.applicationEnvs(args.action, args);
      case 'coolify_logs':
        return await this.handlers.logs(args.action, args.uuid, args.lines);
      case 'coolify_application_deployments':
        return await this.handlers.applicationDeployments(args.action, args);
      
      // Database Management
      case 'coolify_databases':
        return await this.handlers.databases(args.action, args);
      case 'coolify_database_lifecycle':
        return await this.handlers.databaseLifecycle(args.action, args.uuid);
      case 'coolify_database_types':
        return await this.handlers.databaseTypes(args.action, args);
      
      // Server Management
      case 'coolify_servers':
        return await this.handlers.servers(args.action, args);
      case 'coolify_server_management':
        return await this.handlers.serverManagement(args.action, args.uuid);
      
      // Service Management
      case 'coolify_services':
        return await this.handlers.services(args.action, args);
      case 'coolify_service_lifecycle':
        return await this.handlers.serviceLifecycle(args.action, args.uuid);
      case 'coolify_service_envs':
        return await this.handlers.serviceEnvs(args.action, args);
      
      // Security Keys Management
      case 'coolify_security_keys':
        return await this.handlers.securityKeys(args.action, args);
      
      default:
        throw new CoolifyError(`Unknown tool: ${name}`, 400);
    }
  }